Changeset 58749 in vbox
- Timestamp:
- Nov 18, 2015 7:46:11 PM (9 years ago)
- svn:sync-xref-src-repo-rev:
- 104190
- Location:
- trunk/include/iprt
- Files:
-
- 6 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/include/iprt/asm-amd64-x86-watcom-16.h
r58707 r58749 38 38 * seems to insists on loading the DGROUP segment into 'ds' before calling 39 39 * stuff when using -ecc. Using 'es' instead as this seems to work fine. 40 * 41 * Note! The #undef that preceds the #pragma aux statements is for undoing 42 * the mangling, because the symbol in #pragma aux [symbol] statements 43 * doesn't get subjected to preprocessing. This is also why we include 44 * the watcom header at the top rather than at the bottom of the 45 * asm-amd64-x86.h file. 40 46 */ 41 47 48 #undef ASMGetIDTR 42 49 #pragma aux ASMGetIDTR = \ 43 50 "sidt fword ptr es:[bx]" \ … … 45 52 modify exact []; 46 53 54 #undef ASMGetIdtrLimit 47 55 #pragma aux ASMGetIdtrLimit = \ 48 56 "sub sp, 8" \ … … 55 63 modify exact [bx]; 56 64 65 #undef ASMSetIDTR 57 66 #pragma aux ASMSetIDTR = \ 58 67 "lidt fword ptr es:[bx]" \ … … 60 69 modify nomemory; 61 70 71 #undef ASMGetGDTR 62 72 #pragma aux ASMGetGDTR = \ 63 73 "sgdt fword ptr es:[bx]" \ … … 65 75 modify exact []; 66 76 77 #undef ASMSetGDTR 67 78 #pragma aux ASMSetGDTR = \ 68 79 "lgdt fword ptr es:[bx]" \ … … 70 81 modify exact [] nomemory; 71 82 83 #undef ASMGetCS 72 84 #pragma aux ASMGetCS = \ 73 85 "mov ax, cs" \ … … 76 88 modify exact [ax] nomemory; 77 89 90 #undef ASMGetDS 78 91 #pragma aux ASMGetDS = \ 79 92 "mov ax, ds" \ … … 82 95 modify exact [ax] nomemory; 83 96 97 #undef ASMGetES 84 98 #pragma aux ASMGetES = \ 85 99 "mov ax, es" \ … … 88 102 modify exact [ax] nomemory; 89 103 104 #undef ASMGetFS 90 105 #pragma aux ASMGetFS = \ 91 106 "mov ax, fs" \ … … 94 109 modify exact [ax] nomemory; 95 110 111 #undef ASMGetGS 96 112 #pragma aux ASMGetGS = \ 97 113 "mov ax, gs" \ … … 100 116 modify exact [ax] nomemory; 101 117 118 #undef ASMGetSS 102 119 #pragma aux ASMGetSS = \ 103 120 "mov ax, ss" \ … … 106 123 modify exact [ax] nomemory; 107 124 125 #undef ASMGetTR 108 126 #pragma aux ASMGetTR = \ 109 127 "str ax" \ … … 112 130 modify exact [ax] nomemory; 113 131 132 #undef ASMGetLDTR 114 133 #pragma aux ASMGetLDTR = \ 115 134 "sldt ax" \ … … 120 139 /** @todo ASMGetSegAttr */ 121 140 141 #undef ASMGetFlags 122 142 #pragma aux ASMGetFlags = \ 123 143 "pushf" \ … … 127 147 modify exact [ax] nomemory; 128 148 149 #undef ASMSetFlags 129 150 #pragma aux ASMSetFlags = \ 130 151 "push ax" \ … … 133 154 modify exact [] nomemory; 134 155 156 #undef ASMChangeFlags 135 157 #pragma aux ASMChangeFlags = \ 136 158 "pushf" \ … … 144 166 modify exact [dx] nomemory; 145 167 168 #undef ASMAddFlags 146 169 #pragma aux ASMAddFlags = \ 147 170 "pushf" \ … … 154 177 modify exact [dx] nomemory; 155 178 179 #undef ASMClearFlags 156 180 #pragma aux ASMClearFlags = \ 157 181 "pushf" \ … … 166 190 /* Note! Must use the 64-bit integer return value convension. 167 191 The order of registers in the value [set] does not seem to mean anything. */ 192 #undef ASMReadTSC 168 193 #pragma aux ASMReadTSC = \ 169 194 ".586" \ … … 199 224 si:di 200 225 This ordering seems to apply to parameter values too. */ 226 #undef ASMGetCR0 201 227 #pragma aux ASMGetCR0 = \ 202 228 "mov eax, cr0" \ … … 207 233 modify exact [ax dx] nomemory; 208 234 235 #undef ASMSetCR0 209 236 #pragma aux ASMSetCR0 = \ 210 237 "shl edx, 16" \ … … 214 241 modify exact [dx] nomemory; 215 242 243 #undef ASMGetCR2 216 244 #pragma aux ASMGetCR2 = \ 217 245 "mov eax, cr2" \ … … 222 250 modify exact [ax dx] nomemory; 223 251 252 #undef ASMSetCR2 224 253 #pragma aux ASMSetCR2 = \ 225 254 "shl edx, 16" \ … … 229 258 modify exact [dx] nomemory; 230 259 260 #undef ASMGetCR3 231 261 #pragma aux ASMGetCR3 = \ 232 262 "mov eax, cr3" \ … … 237 267 modify exact [ax dx] nomemory; 238 268 269 #undef ASMSetCR3 239 270 #pragma aux ASMSetCR3 = \ 240 271 "shl edx, 16" \ … … 244 275 modify exact [dx] nomemory; 245 276 277 #undef ASMReloadCR3 246 278 #pragma aux ASMReloadCR3 = \ 247 279 "mov eax, cr3" \ … … 250 282 modify exact [ax] nomemory; 251 283 284 #undef ASMGetCR4 252 285 #pragma aux ASMGetCR4 = \ 253 286 "mov eax, cr4" \ … … 258 291 modify exact [ax dx] nomemory; 259 292 293 #undef ASMSetCR4 260 294 #pragma aux ASMSetCR4 = \ 261 295 "shl edx, 16" \ … … 268 302 /* ASMSetCR8: Don't bother for 16-bit. */ 269 303 304 #undef ASMIntEnable 270 305 #pragma aux ASMIntEnable = \ 271 306 "sti" \ … … 273 308 modify exact [] nomemory; 274 309 310 #undef ASMIntDisable 275 311 #pragma aux ASMIntDisable = \ 276 312 "cli" \ … … 278 314 modify exact [] nomemory; 279 315 316 #undef ASMIntDisableFlags 280 317 #pragma aux ASMIntDisableFlags = \ 281 318 "pushf" \ … … 286 323 modify exact [] nomemory; 287 324 325 #undef ASMHalt 288 326 #pragma aux ASMHalt = \ 289 327 "hlt" \ … … 291 329 modify exact [] nomemory; 292 330 331 #undef ASMRdMsr 293 332 #pragma aux ASMRdMsr = \ 294 333 ".586" \ … … 309 348 /* ASMWrMsrEx: Implemented externally, lazy bird. */ 310 349 350 #undef ASMRdMsr_Low 311 351 #pragma aux ASMRdMsr_Low = \ 312 352 ".586" \ … … 320 360 modify exact [ax bx cx dx] nomemory; 321 361 362 #undef ASMRdMsr_High 322 363 #pragma aux ASMRdMsr_High = \ 323 364 ".586" \ … … 332 373 333 374 375 #undef ASMGetDR0 334 376 #pragma aux ASMGetDR0 = \ 335 377 "mov eax, dr0" \ … … 340 382 modify exact [ax dx] nomemory; 341 383 384 #undef ASMGetDR1 342 385 #pragma aux ASMGetDR1 = \ 343 386 "mov eax, dr1" \ … … 348 391 modify exact [ax dx] nomemory; 349 392 393 #undef ASMGetDR2 350 394 #pragma aux ASMGetDR2 = \ 351 395 "mov eax, dr2" \ … … 356 400 modify exact [ax dx] nomemory; 357 401 402 #undef ASMGetDR3 358 403 #pragma aux ASMGetDR3 = \ 359 404 "mov eax, dr3" \ … … 364 409 modify exact [ax dx] nomemory; 365 410 411 #undef ASMGetDR6 366 412 #pragma aux ASMGetDR6 = \ 367 413 "mov eax, dr6" \ … … 372 418 modify exact [ax dx] nomemory; 373 419 420 #undef ASMGetAndClearDR6 374 421 #pragma aux ASMGetAndClearDR6 = \ 375 422 "mov edx, 0ffff0ff0h" \ … … 382 429 modify exact [ax dx] nomemory; 383 430 431 #undef ASMGetDR7 384 432 #pragma aux ASMGetDR7 = \ 385 433 "mov eax, dr7" \ … … 390 438 modify exact [ax dx] nomemory; 391 439 440 #undef ASMSetDR0 392 441 #pragma aux ASMSetDR0 = \ 393 442 "shl edx, 16" \ … … 397 446 modify exact [dx] nomemory; 398 447 448 #undef ASMSetDR1 399 449 #pragma aux ASMSetDR1 = \ 400 450 "shl edx, 16" \ … … 404 454 modify exact [dx] nomemory; 405 455 456 #undef ASMSetDR2 406 457 #pragma aux ASMSetDR2 = \ 407 458 "shl edx, 16" \ … … 411 462 modify exact [dx] nomemory; 412 463 464 #undef ASMSetDR3 413 465 #pragma aux ASMSetDR3 = \ 414 466 "shl edx, 16" \ … … 418 470 modify exact [dx] nomemory; 419 471 472 #undef ASMSetDR6 420 473 #pragma aux ASMSetDR6 = \ 421 474 "shl edx, 16" \ … … 425 478 modify exact [dx] nomemory; 426 479 480 #undef ASMSetDR7 427 481 #pragma aux ASMSetDR7 = \ 428 482 "shl edx, 16" \ … … 433 487 434 488 /* Yeah, could've used outp here, but this keeps the main file simpler. */ 489 #undef ASMOutU8 435 490 #pragma aux ASMOutU8 = \ 436 491 "out dx, al" \ … … 438 493 modify exact [] nomemory; 439 494 495 #undef ASMInU8 440 496 #pragma aux ASMInU8 = \ 441 497 "in al, dx" \ … … 444 500 modify exact [] nomemory; 445 501 502 #undef ASMOutU16 503 #undef ASMOutU16 446 504 #pragma aux ASMOutU16 = \ 447 505 "out dx, ax" \ … … 449 507 modify exact [] nomemory; 450 508 509 #undef ASMInU16 451 510 #pragma aux ASMInU16 = \ 452 511 "in ax, dx" \ … … 455 514 modify exact [] nomemory; 456 515 516 #undef ASMOutU32 457 517 #pragma aux ASMOutU32 = \ 458 518 "shl ecx, 16" \ … … 463 523 modify exact [] nomemory; 464 524 525 #undef ASMInU32 465 526 #pragma aux ASMInU32 = \ 466 527 "in eax, dx" \ … … 471 532 modify exact [] nomemory; 472 533 534 #undef ASMOutStrU8 473 535 #pragma aux ASMOutStrU8 = \ 474 536 "mov ds, bx" \ … … 477 539 modify exact [si cx ds] nomemory; 478 540 541 #undef ASMInStrU8 479 542 #pragma aux ASMInStrU8 = \ 480 543 "rep insb" \ … … 482 545 modify exact [di cx]; 483 546 547 #undef ASMOutStrU16 484 548 #pragma aux ASMOutStrU16 = \ 485 549 "mov ds, bx" \ … … 488 552 modify exact [si cx ds] nomemory; 489 553 554 #undef ASMInStrU16 490 555 #pragma aux ASMInStrU16 = \ 491 556 "rep insw" \ … … 493 558 modify exact [di cx]; 494 559 560 #undef ASMOutStrU32 495 561 #pragma aux ASMOutStrU32 = \ 496 562 "mov ds, bx" \ … … 499 565 modify exact [si cx ds] nomemory; 500 566 567 #undef ASMInStrU32 501 568 #pragma aux ASMInStrU32 = \ 502 569 "rep insd" \ … … 506 573 /* ASMInvalidatePage: When needed. */ 507 574 575 #undef ASMWriteBackAndInvalidateCaches 508 576 #pragma aux ASMWriteBackAndInvalidateCaches = \ 509 577 ".486" \ … … 512 580 modify exact [] nomemory; 513 581 582 #undef ASMInvalidateInternalCaches 514 583 #pragma aux ASMInvalidateInternalCaches = \ 515 584 ".486" \ -
trunk/include/iprt/asm-amd64-x86-watcom-32.h
r58701 r58749 34 34 #endif 35 35 36 36 /* 37 * Note! The #undef that preceds the #pragma aux statements is for undoing 38 * the mangling, because the symbol in #pragma aux [symbol] statements 39 * doesn't get subjected to preprocessing. This is also why we include 40 * the watcom header at the top rather than at the bottom of the 41 * asm-amd64-x86.h file. 42 */ 43 44 #undef ASMGetIDTR 37 45 #pragma aux ASMGetIDTR = \ 38 46 "sidt fword ptr [ecx]" \ … … 40 48 modify exact []; 41 49 50 #undef ASMGetIdtrLimit 42 51 #pragma aux ASMGetIdtrLimit = \ 43 52 "sub esp, 8" \ … … 49 58 modify exact [ecx]; 50 59 60 #undef ASMSetIDTR 51 61 #pragma aux ASMSetIDTR = \ 52 62 "lidt fword ptr [ecx]" \ … … 54 64 modify nomemory; 55 65 66 #undef ASMGetGDTR 56 67 #pragma aux ASMGetGDTR = \ 57 68 "sgdt fword ptr [ecx]" \ … … 59 70 modify exact []; 60 71 72 #undef ASMSetGDTR 61 73 #pragma aux ASMSetGDTR = \ 62 74 "lgdt fword ptr [ecx]" \ … … 64 76 modify exact [] nomemory; 65 77 78 #undef ASMGetCS 66 79 #pragma aux ASMGetCS = \ 67 80 "mov ax, cs" \ … … 70 83 modify exact [eax] nomemory; 71 84 85 #undef ASMGetDS 72 86 #pragma aux ASMGetDS = \ 73 87 "mov ax, ds" \ … … 76 90 modify exact [eax] nomemory; 77 91 92 #undef ASMGetES 78 93 #pragma aux ASMGetES = \ 79 94 "mov ax, es" \ … … 82 97 modify exact [eax] nomemory; 83 98 99 #undef ASMGetFS 84 100 #pragma aux ASMGetFS = \ 85 101 "mov ax, fs" \ … … 88 104 modify exact [eax] nomemory; 89 105 106 #undef ASMGetGS 90 107 #pragma aux ASMGetGS = \ 91 108 "mov ax, gs" \ … … 94 111 modify exact [eax] nomemory; 95 112 113 #undef ASMGetSS 96 114 #pragma aux ASMGetSS = \ 97 115 "mov ax, ss" \ … … 100 118 modify exact [eax] nomemory; 101 119 120 #undef ASMGetTR 102 121 #pragma aux ASMGetTR = \ 103 122 "str ax" \ … … 106 125 modify exact [eax] nomemory; 107 126 127 #undef ASMGetLDTR 108 128 #pragma aux ASMGetLDTR = \ 109 129 "sldt ax" \ … … 114 134 /** @todo ASMGetSegAttr */ 115 135 136 #undef ASMGetFlags 116 137 #pragma aux ASMGetFlags = \ 117 138 "pushfd" \ … … 121 142 modify exact [eax] nomemory; 122 143 144 #undef ASMSetFlags 123 145 #pragma aux ASMSetFlags = \ 124 146 "push eax" \ … … 127 149 modify exact [] nomemory; 128 150 151 #undef ASMChangeFlags 129 152 #pragma aux ASMChangeFlags = \ 130 153 "pushfd" \ … … 138 161 modify exact [edx] nomemory; 139 162 163 #undef ASMAddFlags 140 164 #pragma aux ASMAddFlags = \ 141 165 "pushfd" \ … … 148 172 modify exact [edx] nomemory; 149 173 174 #undef ASMClearFlags 150 175 #pragma aux ASMClearFlags = \ 151 176 "pushfd" \ … … 160 185 /* Note! Must use the 64-bit integer return value convension. 161 186 The order of registers in the value [set] does not seem to mean anything. */ 187 #undef ASMReadTSC 162 188 #pragma aux ASMReadTSC = \ 163 189 ".586" \ … … 167 193 modify exact [edx eax] nomemory; 168 194 195 #undef ASMReadTscWithAux 169 196 #pragma aux ASMReadTscWithAux = \ 170 197 0x0f 0x01 0xf9 \ … … 177 204 /* ASMCpuIdExSlow: Always implemented externally. */ 178 205 206 #undef ASMCpuId_ECX_EDX 179 207 #pragma aux ASMCpuId_ECX_EDX = \ 180 208 "cpuid" \ … … 184 212 modify exact [eax ebx ecx edx]; 185 213 214 #undef ASMCpuId_EAX 186 215 #pragma aux ASMCpuId_EAX = \ 187 216 "cpuid" \ … … 190 219 modify exact [eax ebx ecx edx]; 191 220 221 #undef ASMCpuId_EBX 192 222 #pragma aux ASMCpuId_EBX = \ 193 223 "cpuid" \ … … 196 226 modify exact [eax ebx ecx edx]; 197 227 228 #undef ASMCpuId_ECX 198 229 #pragma aux ASMCpuId_ECX = \ 199 230 "cpuid" \ … … 202 233 modify exact [eax ebx ecx edx]; 203 234 235 #undef ASMCpuId_EDX 204 236 #pragma aux ASMCpuId_EDX = \ 205 237 "cpuid" \ … … 211 243 /* ASMGetApicId: Implemented externally, lazy bird. */ 212 244 245 #undef ASMGetCR0 213 246 #pragma aux ASMGetCR0 = \ 214 247 "mov eax, cr0" \ … … 217 250 modify exact [eax] nomemory; 218 251 252 #undef ASMSetCR0 219 253 #pragma aux ASMSetCR0 = \ 220 254 "mov cr0, eax" \ … … 222 256 modify exact [] nomemory; 223 257 258 #undef ASMGetCR2 224 259 #pragma aux ASMGetCR2 = \ 225 260 "mov eax, cr2" \ … … 228 263 modify exact [eax] nomemory; 229 264 265 #undef ASMSetCR2 230 266 #pragma aux ASMSetCR2 = \ 231 267 "mov cr2, eax" \ … … 233 269 modify exact [] nomemory; 234 270 271 #undef ASMGetCR3 235 272 #pragma aux ASMGetCR3 = \ 236 273 "mov eax, cr3" \ … … 239 276 modify exact [eax] nomemory; 240 277 278 #undef ASMSetCR3 241 279 #pragma aux ASMSetCR3 = \ 242 280 "mov cr3, eax" \ … … 244 282 modify exact [] nomemory; 245 283 284 #undef ASMReloadCR3 246 285 #pragma aux ASMReloadCR3 = \ 247 286 "mov eax, cr3" \ … … 250 289 modify exact [eax] nomemory; 251 290 291 #undef ASMGetCR4 252 292 #pragma aux ASMGetCR4 = \ 253 293 "mov eax, cr4" \ … … 256 296 modify exact [eax] nomemory; 257 297 298 #undef ASMSetCR4 258 299 #pragma aux ASMSetCR4 = \ 259 300 "mov cr4, eax" \ … … 264 305 /* ASMSetCR8: Don't bother for 32-bit. */ 265 306 307 #undef ASMIntEnable 266 308 #pragma aux ASMIntEnable = \ 267 309 "sti" \ … … 269 311 modify exact [] nomemory; 270 312 313 #undef ASMIntDisable 271 314 #pragma aux ASMIntDisable = \ 272 315 "cli" \ … … 274 317 modify exact [] nomemory; 275 318 319 #undef ASMIntDisableFlags 276 320 #pragma aux ASMIntDisableFlags = \ 277 321 "pushfd" \ … … 282 326 modify exact [] nomemory; 283 327 328 #undef ASMHalt 284 329 #pragma aux ASMHalt = \ 285 330 "hlt" \ … … 287 332 modify exact [] nomemory; 288 333 334 #undef ASMRdMsr 289 335 #pragma aux ASMRdMsr = \ 290 336 ".586" \ … … 294 340 modify exact [eax edx] nomemory; 295 341 342 #undef ASMWrMsr 296 343 #pragma aux ASMWrMsr = \ 297 344 ".586" \ … … 300 347 modify exact [] nomemory; 301 348 349 #undef ASMRdMsrEx 302 350 #pragma aux ASMRdMsrEx = \ 303 351 ".586" \ … … 307 355 modify exact [eax edx] nomemory; 308 356 357 #undef ASMWrMsrEx 309 358 #pragma aux ASMWrMsrEx = \ 310 359 ".586" \ … … 313 362 modify exact [] nomemory; 314 363 364 #undef ASMRdMsr_Low 315 365 #pragma aux ASMRdMsr_Low = \ 316 366 ".586" \ … … 320 370 modify exact [eax edx] nomemory; 321 371 372 #undef ASMRdMsr_High 322 373 #pragma aux ASMRdMsr_High = \ 323 374 ".586" \ … … 328 379 329 380 381 #undef ASMGetDR0 330 382 #pragma aux ASMGetDR0 = \ 331 383 "mov eax, dr0" \ … … 334 386 modify exact [eax] nomemory; 335 387 388 #undef ASMGetDR1 336 389 #pragma aux ASMGetDR1 = \ 337 390 "mov eax, dr1" \ … … 340 393 modify exact [eax] nomemory; 341 394 395 #undef ASMGetDR2 342 396 #pragma aux ASMGetDR2 = \ 343 397 "mov eax, dr2" \ … … 346 400 modify exact [eax] nomemory; 347 401 402 #undef ASMGetDR3 348 403 #pragma aux ASMGetDR3 = \ 349 404 "mov eax, dr3" \ … … 352 407 modify exact [eax] nomemory; 353 408 409 #undef ASMGetDR6 354 410 #pragma aux ASMGetDR6 = \ 355 411 "mov eax, dr6" \ … … 358 414 modify exact [eax] nomemory; 359 415 416 #undef ASMGetAndClearDR6 360 417 #pragma aux ASMGetAndClearDR6 = \ 361 418 "mov edx, 0ffff0ff0h" \ … … 366 423 modify exact [eax edx] nomemory; 367 424 425 #undef ASMGetDR7 368 426 #pragma aux ASMGetDR7 = \ 369 427 "mov eax, dr7" \ … … 372 430 modify exact [eax] nomemory; 373 431 432 #undef ASMSetDR0 374 433 #pragma aux ASMSetDR0 = \ 375 434 "mov dr0, eax" \ … … 377 436 modify exact [] nomemory; 378 437 438 #undef ASMSetDR1 379 439 #pragma aux ASMSetDR1 = \ 380 440 "mov dr1, eax" \ … … 382 442 modify exact [] nomemory; 383 443 444 #undef ASMSetDR2 384 445 #pragma aux ASMSetDR2 = \ 385 446 "mov dr2, eax" \ … … 387 448 modify exact [] nomemory; 388 449 450 #undef ASMSetDR3 389 451 #pragma aux ASMSetDR3 = \ 390 452 "mov dr3, eax" \ … … 392 454 modify exact [] nomemory; 393 455 456 #undef ASMSetDR6 394 457 #pragma aux ASMSetDR6 = \ 395 458 "mov dr6, eax" \ … … 397 460 modify exact [] nomemory; 398 461 462 #undef ASMSetDR7 399 463 #pragma aux ASMSetDR7 = \ 400 464 "mov dr7, eax" \ … … 403 467 404 468 /* Yeah, could've used outp here, but this keeps the main file simpler. */ 469 #undef ASMOutU8 405 470 #pragma aux ASMOutU8 = \ 406 471 "out dx, al" \ … … 408 473 modify exact [] nomemory; 409 474 475 #undef ASMInU8 410 476 #pragma aux ASMInU8 = \ 411 477 "in al, dx" \ … … 414 480 modify exact [] nomemory; 415 481 482 #undef ASMOutU16 416 483 #pragma aux ASMOutU16 = \ 417 484 "out dx, ax" \ … … 419 486 modify exact [] nomemory; 420 487 488 #undef ASMInU16 421 489 #pragma aux ASMInU16 = \ 422 490 "in ax, dx" \ … … 425 493 modify exact [] nomemory; 426 494 495 #undef ASMOutU32 427 496 #pragma aux ASMOutU32 = \ 428 497 "out dx, eax" \ … … 430 499 modify exact [] nomemory; 431 500 501 #undef ASMInU32 432 502 #pragma aux ASMInU32 = \ 433 503 "in eax, dx" \ … … 436 506 modify exact [] nomemory; 437 507 508 #undef ASMOutStrU8 438 509 #pragma aux ASMOutStrU8 = \ 439 510 "rep outsb" \ … … 441 512 modify exact [esi ecx] nomemory; 442 513 514 #undef ASMInStrU8 443 515 #pragma aux ASMInStrU8 = \ 444 516 "rep insb" \ … … 446 518 modify exact [edi ecx]; 447 519 520 #undef ASMOutStrU16 448 521 #pragma aux ASMOutStrU16 = \ 449 522 "rep outsw" \ … … 451 524 modify exact [esi ecx] nomemory; 452 525 526 #undef ASMInStrU16 453 527 #pragma aux ASMInStrU16 = \ 454 528 "rep insw" \ … … 456 530 modify exact [edi ecx]; 457 531 532 #undef ASMOutStrU32 458 533 #pragma aux ASMOutStrU32 = \ 459 534 "rep outsd" \ … … 461 536 modify exact [esi ecx] nomemory; 462 537 538 #undef ASMInStrU32 463 539 #pragma aux ASMInStrU32 = \ 464 540 "rep insd" \ … … 466 542 modify exact [edi ecx]; 467 543 544 #undef ASMInvalidatePage 468 545 #pragma aux ASMInvalidatePage = \ 469 546 "invlpg [eax]" \ … … 471 548 modify exact []; 472 549 550 #undef ASMWriteBackAndInvalidateCaches 473 551 #pragma aux ASMWriteBackAndInvalidateCaches = \ 474 552 ".486" \ … … 477 555 modify exact [] nomemory; 478 556 557 #undef ASMInvalidateInternalCaches 479 558 #pragma aux ASMInvalidateInternalCaches = \ 480 559 ".486" \ -
trunk/include/iprt/asm-amd64-x86.h
r58711 r58749 78 78 79 79 80 /* 81 * Include #pragma aux definitions for Watcom C/C++. 82 */ 83 #if defined(__WATCOMC__) && ARCH_BITS == 16 84 # include "asm-amd64-x86-watcom-16.h" 85 #elif defined(__WATCOMC__) && ARCH_BITS == 32 86 # include "asm-amd64-x86-watcom-32.h" 87 #endif 88 80 89 81 90 /** @defgroup grp_rt_asm_amd64_x86 AMD64 and x86 Specific ASM Routines … … 3322 3331 #endif /* !_MSC_VER) || !RT_ARCH_AMD64 */ 3323 3332 3324 /*3325 * Include #pragma aux definitions for Watcom C/C++.3326 */3327 #if defined(__WATCOMC__) && ARCH_BITS == 163328 # include "asm-amd64-x86-watcom-16.h"3329 #elif defined(__WATCOMC__) && ARCH_BITS == 323330 # include "asm-amd64-x86-watcom-32.h"3331 #endif3332 3333 3333 /** @} */ 3334 3334 #endif -
trunk/include/iprt/asm-watcom-x86-16.h
r58710 r58749 38 38 * seems to insists on loading the DGROUP segment into 'ds' before calling 39 39 * stuff when using -ecc. Using 'es' instead as this seems to work fine. 40 * 41 * Note! The #undef that preceds the #pragma aux statements is for undoing 42 * the mangling, because the symbol in #pragma aux [symbol] statements 43 * doesn't get subjected to preprocessing. This is also why we include 44 * the watcom header at the top rather than at the bottom of the 45 * asm-amd64-x86.h file. 40 46 */ 41 47 48 #undef ASMCompilerBarrier 42 49 #if 0 /* overkill version. */ 43 50 # pragma aux ASMCompilerBarrier = \ … … 52 59 #endif 53 60 61 #undef ASMNopPause 54 62 #pragma aux ASMNopPause = \ 55 63 ".686p" \ … … 59 67 modify exact [] nomemory; 60 68 69 #undef ASMAtomicXchgU8 61 70 #pragma aux ASMAtomicXchgU8 = \ 62 71 "xchg es:[bx], al" \ … … 65 74 modify exact [al]; 66 75 76 #undef ASMAtomicXchgU16 67 77 #pragma aux ASMAtomicXchgU16 = \ 68 78 "xchg es:[bx], ax" \ … … 71 81 modify exact [ax]; 72 82 83 #undef ASMAtomicXchgU32 73 84 #pragma aux ASMAtomicXchgU32 = \ 74 85 "shl ecx, 16" \ … … 81 92 modify exact [ax cx]; 82 93 94 #undef ASMAtomicXchgU64 83 95 #pragma aux ASMAtomicXchgU64 = \ 84 96 ".586" \ … … 101 113 modify exact [dx cx bx ax]; 102 114 115 #undef ASMAtomicCmpXchgU8 103 116 #pragma aux ASMAtomicCmpXchgU8 = \ 104 117 ".486" \ … … 109 122 modify exact [al]; 110 123 124 #undef ASMAtomicCmpXchgU16 111 125 #pragma aux ASMAtomicCmpXchgU16 = \ 112 126 ".486" \ … … 117 131 modify exact [ax]; 118 132 133 #undef ASMAtomicCmpXchgU32 119 134 #pragma aux ASMAtomicCmpXchgU32 = \ 120 135 ".486" \ … … 134 149 /* ASMAtomicCmpXchgExU64: External assembly implementation, too few registers for parameters. */ 135 150 151 #undef ASMSerializeInstruction 136 152 #pragma aux ASMSerializeInstruction = \ 137 153 ".586" \ … … 141 157 modify exact [ax bx cx dx]; 142 158 159 #undef ASMAtomicReadU64 143 160 #pragma aux ASMAtomicReadU64 = \ 144 161 ".586" \ … … 157 174 modify exact [dx cx bx ax]; 158 175 176 #undef ASMAtomicUoReadU64 159 177 #pragma aux ASMAtomicUoReadU64 = \ 160 178 ".586" \ … … 173 191 modify exact [dx cx bx ax]; 174 192 193 #undef ASMAtomicAddU16 175 194 #pragma aux ASMAtomicAddU16 = \ 176 195 ".486" \ … … 180 199 modify exact [ax]; 181 200 201 #undef ASMAtomicAddU32 182 202 #pragma aux ASMAtomicAddU32 = \ 183 203 ".486" \ … … 191 211 modify exact [ax dx]; 192 212 213 #undef ASMAtomicIncU16 193 214 #pragma aux ASMAtomicIncU16 = \ 194 215 ".486" \ … … 200 221 modify exact [ax]; 201 222 223 #undef ASMAtomicIncU32 202 224 #pragma aux ASMAtomicIncU32 = \ 203 225 ".486" \ … … 213 235 /* ASMAtomicIncU64: Should be done by C inline or in external file. */ 214 236 237 #undef ASMAtomicDecU16 215 238 #pragma aux ASMAtomicDecU16 = \ 216 239 ".486" \ … … 222 245 modify exact [ax]; 223 246 247 #undef ASMAtomicDecU32 224 248 #pragma aux ASMAtomicDecU32 = \ 225 249 ".486" \ … … 235 259 /* ASMAtomicDecU64: Should be done by C inline or in external file. */ 236 260 261 #undef ASMAtomicOrU32 237 262 #pragma aux ASMAtomicOrU32 = \ 238 263 "shl edx, 16" \ … … 244 269 /* ASMAtomicOrU64: Should be done by C inline or in external file. */ 245 270 271 #undef ASMAtomicAndU32 246 272 #pragma aux ASMAtomicAndU32 = \ 247 273 "shl edx, 16" \ … … 253 279 /* ASMAtomicAndU64: Should be done by C inline or in external file. */ 254 280 281 #undef ASMAtomicUoOrU32 255 282 #pragma aux ASMAtomicUoOrU32 = \ 256 283 "shl edx, 16" \ … … 262 289 /* ASMAtomicUoOrU64: Should be done by C inline or in external file. */ 263 290 291 #undef ASMAtomicUoAndU32 264 292 #pragma aux ASMAtomicUoAndU32 = \ 265 293 "shl edx, 16" \ … … 271 299 /* ASMAtomicUoAndU64: Should be done by C inline or in external file. */ 272 300 301 #undef ASMAtomicUoIncU32 273 302 #pragma aux ASMAtomicUoIncU32 = \ 274 303 ".486" \ … … 282 311 modify exact [ax dx]; 283 312 313 #undef ASMAtomicUoDecU32 284 314 #pragma aux ASMAtomicUoDecU32 = \ 285 315 ".486" \ … … 293 323 modify exact [ax dx]; 294 324 325 #undef ASMMemZeroPage 295 326 #pragma aux ASMMemZeroPage = \ 296 327 "mov ecx, 1024" \ … … 300 331 modify exact [ax cx di]; 301 332 333 #undef ASMMemZero32 302 334 #pragma aux ASMMemZero32 = \ 303 335 "and ecx, 0ffffh" /* probably not necessary, lazy bird should check... */ \ … … 308 340 modify exact [ax cx di]; 309 341 342 #undef ASMMemZero32 310 343 #pragma aux ASMMemZero32 = \ 311 344 "and ecx, 0ffffh" /* probably not necessary, lazy bird should check... */ \ … … 318 351 modify exact [ax cx di]; 319 352 353 #undef ASMProbeReadByte 320 354 #pragma aux ASMProbeReadByte = \ 321 355 "mov al, es:[bx]" \ … … 324 358 modify exact [al]; 325 359 360 #undef ASMBitSet 326 361 #pragma aux ASMBitSet = \ 327 362 "shl edx, 16" \ … … 331 366 modify exact [dx]; 332 367 368 #undef ASMAtomicBitSet 333 369 #pragma aux ASMAtomicBitSet = \ 334 370 "shl edx, 16" \ … … 338 374 modify exact [dx]; 339 375 376 #undef ASMBitClear 340 377 #pragma aux ASMBitClear = \ 341 378 "shl edx, 16" \ … … 345 382 modify exact [dx]; 346 383 384 #undef ASMAtomicBitClear 347 385 #pragma aux ASMAtomicBitClear = \ 348 386 "shl edx, 16" \ … … 352 390 modify exact [dx]; 353 391 392 #undef ASMBitToggle 354 393 #pragma aux ASMBitToggle = \ 355 394 "shl edx, 16" \ … … 359 398 modify exact [dx]; 360 399 400 #undef ASMAtomicBitToggle 361 401 #pragma aux ASMAtomicBitToggle = \ 362 402 "shl edx, 16" \ … … 365 405 parm [es bx] [ax dx] \ 366 406 modify exact [dx]; 367 /// 368 /// 407 408 #undef ASMBitTestAndSet 369 409 #pragma aux ASMBitTestAndSet = \ 370 410 "shl edx, 16" \ … … 376 416 modify exact [ax dx]; 377 417 418 #undef ASMAtomicBitTestAndSet 378 419 #pragma aux ASMAtomicBitTestAndSet = \ 379 420 "shl edx, 16" \ … … 385 426 modify exact [ax dx]; 386 427 428 #undef ASMBitTestAndClear 387 429 #pragma aux ASMBitTestAndClear = \ 388 430 "shl edx, 16" \ … … 394 436 modify exact [ax dx]; 395 437 438 #undef ASMAtomicBitTestAndClear 396 439 #pragma aux ASMAtomicBitTestAndClear = \ 397 440 "shl edx, 16" \ … … 403 446 modify exact [ax dx]; 404 447 448 #undef ASMBitTestAndToggle 405 449 #pragma aux ASMBitTestAndToggle = \ 406 450 "shl edx, 16" \ … … 412 456 modify exact [ax dx]; 413 457 458 #undef ASMAtomicBitTestAndToggle 414 459 #pragma aux ASMAtomicBitTestAndToggle = \ 415 460 "shl edx, 16" \ … … 422 467 423 468 /** @todo this is way to much inline assembly, better off in an external function. */ 469 #undef ASMBitFirstClear 424 470 #pragma aux ASMBitFirstClear = \ 425 471 "mov bx, di" /* save start of bitmap for later */ \ … … 449 495 450 496 /** @todo this is way to much inline assembly, better off in an external function. */ 497 #undef ASMBitFirstSet 451 498 #pragma aux ASMBitFirstSet = \ 452 499 "mov bx, di" /* save start of bitmap for later */ \ … … 475 522 /* ASMBitNextSet: Too much work, do when needed. */ 476 523 524 #undef ASMBitFirstSetU32 477 525 #pragma aux ASMBitFirstSetU32 = \ 478 526 "shl edx, 16" \ … … 489 537 modify exact [ax dx] nomemory; 490 538 539 #undef ASMBitLastSetU32 491 540 #pragma aux ASMBitLastSetU32 = \ 492 541 "shl edx, 16" \ … … 503 552 modify exact [ax dx] nomemory; 504 553 554 #undef ASMByteSwapU16 505 555 #pragma aux ASMByteSwapU16 = \ 506 556 "ror ax, 8" \ … … 509 559 modify exact [ax] nomemory; 510 560 561 #undef ASMByteSwapU32 511 562 #pragma aux ASMByteSwapU32 = \ 512 563 "xchg ax, dx" \ … … 515 566 modify exact [ax dx] nomemory; 516 567 568 #undef ASMRotateLeftU32 517 569 #pragma aux ASMRotateLeftU32 = \ 518 570 "shl edx, 16" \ … … 525 577 modify exact [ax dx] nomemory; 526 578 579 #undef ASMRotateRightU32 527 580 #pragma aux ASMRotateRightU32 = \ 528 581 "shl edx, 16" \ -
trunk/include/iprt/asm-watcom-x86-32.h
r58709 r58749 35 35 36 36 /* 37 * Turns out we cannot use 'ds' for segment stuff here because the compiler 38 * seems to insists on loading the DGROUP segment into 'ds' before calling 39 * stuff when using -ecc. Using 'es' instead as this seems to work fine. 37 * Note! The #undef that preceds the #pragma aux statements is for undoing 38 * the mangling, because the symbol in #pragma aux [symbol] statements 39 * doesn't get subjected to preprocessing. This is also why we include 40 * the watcom header at the top rather than at the bottom of the 41 * asm-amd64-x86.h file. 40 42 */ 41 43 44 #undef ASMCompilerBarrier 42 45 #if 0 /* overkill version. */ 43 46 # pragma aux ASMCompilerBarrier = \ … … 52 55 #endif 53 56 57 #undef ASMNopPause 54 58 #pragma aux ASMNopPause = \ 55 59 ".686p" \ … … 59 63 modify exact [] nomemory; 60 64 65 #undef ASMAtomicXchgU8 61 66 #pragma aux ASMAtomicXchgU8 = \ 62 67 "xchg [ecx], al" \ … … 65 70 modify exact [al]; 66 71 72 #undef ASMAtomicXchgU16 67 73 #pragma aux ASMAtomicXchgU16 = \ 68 74 "xchg [ecx], ax" \ … … 71 77 modify exact [ax]; 72 78 79 #undef ASMAtomicXchgU32 73 80 #pragma aux ASMAtomicXchgU32 = \ 74 81 "xchg [ecx], eax" \ … … 77 84 modify exact [eax]; 78 85 86 #undef ASMAtomicXchgU64 79 87 #pragma aux ASMAtomicXchgU64 = \ 80 88 ".586" \ … … 86 94 modify exact [edx ecx ebx eax]; 87 95 96 #undef ASMAtomicCmpXchgU8 88 97 #pragma aux ASMAtomicCmpXchgU8 = \ 89 98 ".486" \ … … 94 103 modify exact [al]; 95 104 105 #undef ASMAtomicCmpXchgU16 96 106 #pragma aux ASMAtomicCmpXchgU16 = \ 97 107 ".486" \ … … 102 112 modify exact [ax]; 103 113 114 #undef ASMAtomicCmpXchgU32 104 115 #pragma aux ASMAtomicCmpXchgU32 = \ 105 116 ".486" \ … … 110 121 modify exact [eax]; 111 122 123 #undef ASMAtomicCmpXchgU64 112 124 #pragma aux ASMAtomicCmpXchgU64 = \ 113 125 ".586" \ … … 118 130 modify exact [eax edx]; 119 131 132 #undef ASMAtomicCmpXchgExU32 120 133 #pragma aux ASMAtomicCmpXchgExU32 = \ 121 134 ".586" \ … … 127 140 modify exact [eax]; 128 141 142 #undef ASMAtomicCmpXchgExU64 129 143 #pragma aux ASMAtomicCmpXchgExU64 = \ 130 144 ".586" \ … … 137 151 modify exact [eax edx]; 138 152 153 #undef ASMSerializeInstruction 139 154 #pragma aux ASMSerializeInstruction = \ 140 155 ".586" \ … … 144 159 modify exact [eax ebx ecx edx]; 145 160 161 #undef ASMAtomicReadU64 146 162 #pragma aux ASMAtomicReadU64 = \ 147 163 ".586" \ … … 155 171 modify exact [eax ebx ecx edx]; 156 172 173 #undef ASMAtomicUoReadU64 157 174 #pragma aux ASMAtomicUoReadU64 = \ 158 175 ".586" \ … … 166 183 modify exact [eax ebx ecx edx]; 167 184 185 #undef ASMAtomicAddU16 168 186 #pragma aux ASMAtomicAddU16 = \ 169 187 ".486" \ … … 173 191 modify exact [ax]; 174 192 193 #undef ASMAtomicAddU32 175 194 #pragma aux ASMAtomicAddU32 = \ 176 195 ".486" \ … … 180 199 modify exact [eax]; 181 200 201 #undef ASMAtomicIncU16 182 202 #pragma aux ASMAtomicIncU16 = \ 183 203 ".486" \ … … 189 209 modify exact [ax]; 190 210 211 #undef ASMAtomicIncU32 191 212 #pragma aux ASMAtomicIncU32 = \ 192 213 ".486" \ … … 200 221 /* ASMAtomicIncU64: Should be done by C inline or in external file. */ 201 222 223 #undef ASMAtomicDecU16 202 224 #pragma aux ASMAtomicDecU16 = \ 203 225 ".486" \ … … 209 231 modify exact [ax]; 210 232 233 #undef ASMAtomicDecU32 211 234 #pragma aux ASMAtomicDecU32 = \ 212 235 ".486" \ … … 220 243 /* ASMAtomicDecU64: Should be done by C inline or in external file. */ 221 244 245 #undef ASMAtomicOrU32 222 246 #pragma aux ASMAtomicOrU32 = \ 223 247 "lock or [ecx], eax" \ … … 227 251 /* ASMAtomicOrU64: Should be done by C inline or in external file. */ 228 252 253 #undef ASMAtomicAndU32 229 254 #pragma aux ASMAtomicAndU32 = \ 230 255 "lock and [ecx], eax" \ … … 234 259 /* ASMAtomicAndU64: Should be done by C inline or in external file. */ 235 260 261 #undef ASMAtomicUoOrU32 236 262 #pragma aux ASMAtomicUoOrU32 = \ 237 263 "or [ecx], eax" \ … … 241 267 /* ASMAtomicUoOrU64: Should be done by C inline or in external file. */ 242 268 269 #undef ASMAtomicUoAndU32 243 270 #pragma aux ASMAtomicUoAndU32 = \ 244 271 "and [ecx], eax" \ … … 248 275 /* ASMAtomicUoAndU64: Should be done by C inline or in external file. */ 249 276 277 #undef ASMAtomicUoIncU32 250 278 #pragma aux ASMAtomicUoIncU32 = \ 251 279 ".486" \ … … 256 284 modify exact [eax]; 257 285 286 #undef ASMAtomicUoDecU32 258 287 #pragma aux ASMAtomicUoDecU32 = \ 259 288 ".486" \ … … 265 294 modify exact [eax]; 266 295 296 #undef ASMMemZeroPage 267 297 #pragma aux ASMMemZeroPage = \ 268 298 "mov ecx, 1024" \ … … 272 302 modify exact [eax ecx edi]; 273 303 304 #undef ASMMemZero32 274 305 #pragma aux ASMMemZero32 = \ 275 306 "shr ecx, 2" \ … … 279 310 modify exact [eax ecx edi]; 280 311 312 #undef ASMMemZero32 281 313 #pragma aux ASMMemZero32 = \ 282 314 "shr ecx, 2" \ … … 285 317 modify exact [ecx edi]; 286 318 319 #undef ASMProbeReadByte 287 320 #pragma aux ASMProbeReadByte = \ 288 321 "mov al, [ecx]" \ … … 291 324 modify exact [al]; 292 325 326 #undef ASMBitSet 293 327 #pragma aux ASMBitSet = \ 294 328 "bts [ecx], eax" \ … … 296 330 modify exact []; 297 331 332 #undef ASMAtomicBitSet 298 333 #pragma aux ASMAtomicBitSet = \ 299 334 "lock bts [ecx], eax" \ … … 301 336 modify exact []; 302 337 338 #undef ASMBitClear 303 339 #pragma aux ASMBitClear = \ 304 340 "btr [ecx], eax" \ … … 306 342 modify exact []; 307 343 344 #undef ASMAtomicBitClear 308 345 #pragma aux ASMAtomicBitClear = \ 309 346 "lock btr [ecx], eax" \ … … 311 348 modify exact []; 312 349 350 #undef ASMBitToggle 313 351 #pragma aux ASMBitToggle = \ 314 352 "btc [ecx], eax" \ … … 316 354 modify exact []; 317 355 356 #undef ASMAtomicBitToggle 318 357 #pragma aux ASMAtomicBitToggle = \ 319 358 "lock btc [ecx], eax" \ … … 322 361 323 362 363 #undef ASMBitTestAndSet 324 364 #pragma aux ASMBitTestAndSet = \ 325 365 "bts [ecx], eax" \ … … 329 369 modify exact [eax]; 330 370 371 #undef ASMAtomicBitTestAndSet 331 372 #pragma aux ASMAtomicBitTestAndSet = \ 332 373 "lock bts [ecx], eax" \ … … 336 377 modify exact [eax]; 337 378 379 #undef ASMBitTestAndClear 338 380 #pragma aux ASMBitTestAndClear = \ 339 381 "btr [ecx], eax" \ … … 343 385 modify exact [eax]; 344 386 387 #undef ASMAtomicBitTestAndClear 345 388 #pragma aux ASMAtomicBitTestAndClear = \ 346 389 "lock btr [ecx], eax" \ … … 350 393 modify exact [eax]; 351 394 395 #undef ASMBitTestAndToggle 352 396 #pragma aux ASMBitTestAndToggle = \ 353 397 "btc [ecx], eax" \ … … 357 401 modify exact [eax]; 358 402 403 #undef ASMAtomicBitTestAndToggle 359 404 #pragma aux ASMAtomicBitTestAndToggle = \ 360 405 "lock btc [ecx], eax" \ … … 365 410 366 411 /** @todo this is way to much inline assembly, better off in an external function. */ 412 #undef ASMBitFirstClear 367 413 #pragma aux ASMBitFirstClear = \ 368 414 "mov edx, edi" /* save start of bitmap for later */ \ … … 387 433 388 434 /** @todo this is way to much inline assembly, better off in an external function. */ 435 #undef ASMBitFirstSet 389 436 #pragma aux ASMBitFirstSet = \ 390 437 "mov edx, edi" /* save start of bitmap for later */ \ … … 408 455 /* ASMBitNextSet: Too much work, do when needed. */ 409 456 457 #undef ASMBitFirstSetU32 410 458 #pragma aux ASMBitFirstSetU32 = \ 411 459 "bsf eax, eax" \ … … 420 468 modify exact [eax] nomemory; 421 469 470 #undef ASMBitLastSetU32 422 471 #pragma aux ASMBitLastSetU32 = \ 423 472 "bsr eax, eax" \ … … 432 481 modify exact [eax] nomemory; 433 482 483 #undef ASMByteSwapU16 434 484 #pragma aux ASMByteSwapU16 = \ 435 485 "ror ax, 8" \ … … 438 488 modify exact [ax] nomemory; 439 489 490 #undef ASMByteSwapU32 440 491 #pragma aux ASMByteSwapU32 = \ 441 492 "bswap eax" \ … … 444 495 modify exact [eax] nomemory; 445 496 497 #undef ASMRotateLeftU32 446 498 #pragma aux ASMRotateLeftU32 = \ 447 499 "rol eax, cl" \ … … 450 502 modify exact [eax] nomemory; 451 503 504 #undef ASMRotateRightU32 452 505 #pragma aux ASMRotateRightU32 = \ 453 506 "ror eax, cl" \ -
trunk/include/iprt/asm.h
r58718 r58749 82 82 #endif 83 83 84 /* 85 * Include #pragma aux definitions for Watcom C/C++. 86 */ 87 #if defined(__WATCOMC__) && ARCH_BITS == 16 && defined(RT_ARCH_X86) 88 # include "asm-watcom-x86-16.h" 89 #elif defined(__WATCOMC__) && ARCH_BITS == 32 && defined(RT_ARCH_X86) 90 # include "asm-watcom-x86-32.h" 91 #endif 92 93 84 94 85 95 /** @defgroup grp_rt_asm ASM - Assembly Routines … … 5109 5119 5110 5120 5111 /*5112 * Include #pragma aux definitions for Watcom C/C++.5113 */5114 #if defined(__WATCOMC__) && ARCH_BITS == 16 && defined(RT_ARCH_X86)5115 # include "asm-watcom-x86-16.h"5116 #elif defined(__WATCOMC__) && ARCH_BITS == 32 && defined(RT_ARCH_X86)5117 # include "asm-watcom-x86-32.h"5118 #endif5119 5120 5121 5121 /** @} */ 5122 5122
Note:
See TracChangeset
for help on using the changeset viewer.