From ac07e589b3e912c704c2011d543f18b16712ff15 Mon Sep 17 00:00:00 2001 From: Kartik Agaram Date: Sat, 29 Dec 2018 15:27:18 -0800 Subject: 4890 - new html renderings a) Switch to a light background. b) Linkify calls in .subx files. c) Keep all colorization in the Vim colorscheme, get rid of hacky special-cases in update_html. --- html/subx/015immediate_addressing.cc.html | 232 +++++++++++++++--------------- 1 file changed, 116 insertions(+), 116 deletions(-) (limited to 'html/subx/015immediate_addressing.cc.html') diff --git a/html/subx/015immediate_addressing.cc.html b/html/subx/015immediate_addressing.cc.html index 989e30a5..11597b73 100644 --- a/html/subx/015immediate_addressing.cc.html +++ b/html/subx/015immediate_addressing.cc.html @@ -7,29 +7,24 @@ - + @@ -68,7 +63,7 @@ if ('onhashchange' in window) { 1 //: instructions that (immediately) contain an argument to act with 2 3 :(before "End Initialize Op Names") - 4 put_new(Name, "81", "combine rm32 with imm32 based on subop (add/sub/and/or/xor/cmp)"); + 4 put_new(Name, "81", "combine rm32 with imm32 based on subop (add/sub/and/or/xor/cmp)"); 5 6 :(scenario add_imm32_to_r32) 7 % Reg[EBX].i = 1; @@ -76,15 +71,15 @@ if ('onhashchange' in window) { 9 # op ModR/M SIB displacement immediate 10 81 c3 0a 0b 0c 0d # add 0x0d0c0b0a to EBX 11 # ModR/M in binary: 11 (direct mode) 000 (add imm32) 011 (dest EBX) - 12 +run: combine imm32 with r/m32 + 12 +run: combine imm32 with r/m32 13 +run: r/m32 is EBX - 14 +run: imm32 is 0x0d0c0b0a + 14 +run: imm32 is 0x0d0c0b0a 15 +run: subop add 16 +run: storing 0x0d0c0b0b 17 18 :(before "End Single-Byte Opcodes") 19 case 0x81: { // combine imm32 with r/m32 - 20 trace(90, "run") << "combine imm32 with r/m32" << end(); + 20 trace(90, "run") << "combine imm32 with r/m32" << end(); 21 const uint8_t modrm = next(); 22 int32_t* arg1 = effective_address(modrm); 23 const int32_t arg2 = next32(); @@ -97,7 +92,7 @@ if ('onhashchange' in window) { 30 break; 31 // End Op 81 Subops 32 default: - 33 cerr << "unrecognized sub-opcode after 81: " << NUM(subop) << '\n'; + 33 cerr << "unrecognized subop for opcode 81: " << NUM(subop) << '\n'; 34 exit(1); 35 } 36 break; @@ -113,29 +108,29 @@ if ('onhashchange' in window) { 46 # ModR/M in binary: 00 (indirect mode) 000 (add imm32) 011 (dest EBX) 47 == 0x2000 # data segment 48 01 00 00 00 # 1 - 49 +run: combine imm32 with r/m32 + 49 +run: combine imm32 with r/m32 50 +run: effective address is 0x00002000 (EBX) - 51 +run: imm32 is 0x0d0c0b0a + 51 +run: imm32 is 0x0d0c0b0a 52 +run: subop add 53 +run: storing 0x0d0c0b0b 54 55 //:: subtract 56 57 :(before "End Initialize Op Names") - 58 put_new(Name, "2d", "subtract imm32 from EAX (sub)"); + 58 put_new(Name, "2d", "subtract imm32 from EAX (sub)"); 59 60 :(scenario subtract_imm32_from_eax) 61 % Reg[EAX].i = 0x0d0c0baa; 62 == 0x1 63 # op ModR/M SIB displacement immediate 64 2d 0a 0b 0c 0d # subtract 0x0d0c0b0a from EAX - 65 +run: subtract imm32 0x0d0c0b0a from EAX + 65 +run: subtract imm32 0x0d0c0b0a from EAX 66 +run: storing 0x000000a0 67 68 :(before "End Single-Byte Opcodes") 69 case 0x2d: { // subtract imm32 from EAX 70 const int32_t arg2 = next32(); - 71 trace(90, "run") << "subtract imm32 0x" << HEXWORD << arg2 << " from EAX" << end(); + 71 trace(90, "run") << "subtract imm32 0x" << HEXWORD << arg2 << " from EAX" << end(); 72 BINARY_ARITHMETIC_OP(-, Reg[EAX].i, arg2); 73 break; 74 } @@ -150,9 +145,9 @@ if ('onhashchange' in window) { 83 # ModR/M in binary: 00 (indirect mode) 101 (subtract imm32) 011 (dest EBX) 84 == 0x2000 # data segment 85 0a 00 00 00 # 10 - 86 +run: combine imm32 with r/m32 + 86 +run: combine imm32 with r/m32 87 +run: effective address is 0x00002000 (EBX) - 88 +run: imm32 is 0x00000001 + 88 +run: imm32 is 0x00000001 89 +run: subop subtract 90 +run: storing 0x00000009 91 @@ -171,9 +166,9 @@ if ('onhashchange' in window) { 104 # op ModR/M SIB displacement immediate 105 81 eb 01 00 00 00 # subtract 1 from EBX 106 # ModR/M in binary: 11 (direct mode) 101 (subtract imm32) 011 (dest EBX) -107 +run: combine imm32 with r/m32 +107 +run: combine imm32 with r/m32 108 +run: r/m32 is EBX -109 +run: imm32 is 0x00000001 +109 +run: imm32 is 0x00000001 110 +run: subop subtract 111 +run: storing 0x00000009 112 @@ -217,7 +212,7 @@ if ('onhashchange' in window) { 150 } 151 // End Op c1 Subops 152 default: -153 cerr << "unrecognized sub-opcode after c1: " << NUM(subop) << '\n'; +153 cerr << "unrecognized subop for opcode c1: " << NUM(subop) << '\n'; 154 exit(1); 155 } 156 break; @@ -331,20 +326,20 @@ if ('onhashchange' in window) { 264 //:: and 265 266 :(before "End Initialize Op Names") -267 put_new(Name, "25", "EAX = bitwise AND of imm32 with EAX (and)"); +267 put_new(Name, "25", "EAX = bitwise AND of imm32 with EAX (and)"); 268 269 :(scenario and_imm32_with_eax) 270 % Reg[EAX].i = 0xff; 271 == 0x1 272 # op ModR/M SIB displacement immediate 273 25 0a 0b 0c 0d # and 0x0d0c0b0a with EAX -274 +run: and imm32 0x0d0c0b0a with EAX +274 +run: and imm32 0x0d0c0b0a with EAX 275 +run: storing 0x0000000a 276 277 :(before "End Single-Byte Opcodes") 278 case 0x25: { // and imm32 with EAX 279 const int32_t arg2 = next32(); -280 trace(90, "run") << "and imm32 0x" << HEXWORD << arg2 << " with EAX" << end(); +280 trace(90, "run") << "and imm32 0x" << HEXWORD << arg2 << " with EAX" << end(); 281 BINARY_BITWISE_OP(&, Reg[EAX].i, arg2); 282 break; 283 } @@ -359,9 +354,9 @@ if ('onhashchange' in window) { 292 # ModR/M in binary: 00 (indirect mode) 100 (and imm32) 011 (dest EBX) 293 == 0x2000 # data segment 294 ff 00 00 00 # 0xff -295 +run: combine imm32 with r/m32 +295 +run: combine imm32 with r/m32 296 +run: effective address is 0x00002000 (EBX) -297 +run: imm32 is 0x0d0c0b0a +297 +run: imm32 is 0x0d0c0b0a 298 +run: subop and 299 +run: storing 0x0000000a 300 @@ -380,29 +375,29 @@ if ('onhashchange' in window) { 313 # op ModR/M SIB displacement immediate 314 81 e3 0a 0b 0c 0d # and 0x0d0c0b0a with EBX 315 # ModR/M in binary: 11 (direct mode) 100 (and imm32) 011 (dest EBX) -316 +run: combine imm32 with r/m32 +316 +run: combine imm32 with r/m32 317 +run: r/m32 is EBX -318 +run: imm32 is 0x0d0c0b0a +318 +run: imm32 is 0x0d0c0b0a 319 +run: subop and 320 +run: storing 0x0000000a 321 322 //:: or 323 324 :(before "End Initialize Op Names") -325 put_new(Name, "0d", "EAX = bitwise OR of imm32 with EAX (or)"); +325 put_new(Name, "0d", "EAX = bitwise OR of imm32 with EAX (or)"); 326 327 :(scenario or_imm32_with_eax) 328 % Reg[EAX].i = 0xd0c0b0a0; 329 == 0x1 330 # op ModR/M SIB displacement immediate 331 0d 0a 0b 0c 0d # or 0x0d0c0b0a with EAX -332 +run: or imm32 0x0d0c0b0a with EAX +332 +run: or imm32 0x0d0c0b0a with EAX 333 +run: storing 0xddccbbaa 334 335 :(before "End Single-Byte Opcodes") 336 case 0x0d: { // or imm32 with EAX 337 const int32_t arg2 = next32(); -338 trace(90, "run") << "or imm32 0x" << HEXWORD << arg2 << " with EAX" << end(); +338 trace(90, "run") << "or imm32 0x" << HEXWORD << arg2 << " with EAX" << end(); 339 BINARY_BITWISE_OP(|, Reg[EAX].i, arg2); 340 break; 341 } @@ -417,9 +412,9 @@ if ('onhashchange' in window) { 350 # ModR/M in binary: 00 (indirect mode) 001 (or imm32) 011 (dest EBX) 351 == 0x2000 # data segment 352 a0 b0 c0 d0 # 0xd0c0b0a0 -353 +run: combine imm32 with r/m32 +353 +run: combine imm32 with r/m32 354 +run: effective address is 0x00002000 (EBX) -355 +run: imm32 is 0x0d0c0b0a +355 +run: imm32 is 0x0d0c0b0a 356 +run: subop or 357 +run: storing 0xddccbbaa 358 @@ -436,29 +431,29 @@ if ('onhashchange' in window) { 369 # op ModR/M SIB displacement immediate 370 81 cb 0a 0b 0c 0d # or 0x0d0c0b0a with EBX 371 # ModR/M in binary: 11 (direct mode) 001 (or imm32) 011 (dest EBX) -372 +run: combine imm32 with r/m32 +372 +run: combine imm32 with r/m32 373 +run: r/m32 is EBX -374 +run: imm32 is 0x0d0c0b0a +374 +run: imm32 is 0x0d0c0b0a 375 +run: subop or 376 +run: storing 0xddccbbaa 377 378 //:: xor 379 380 :(before "End Initialize Op Names") -381 put_new(Name, "35", "EAX = bitwise XOR of imm32 with EAX (xor)"); +381 put_new(Name, "35", "EAX = bitwise XOR of imm32 with EAX (xor)"); 382 383 :(scenario xor_imm32_with_eax) 384 % Reg[EAX].i = 0xddccb0a0; 385 == 0x1 386 # op ModR/M SIB displacement immediate 387 35 0a 0b 0c 0d # xor 0x0d0c0b0a with EAX -388 +run: xor imm32 0x0d0c0b0a with EAX +388 +run: xor imm32 0x0d0c0b0a with EAX 389 +run: storing 0xd0c0bbaa 390 391 :(before "End Single-Byte Opcodes") 392 case 0x35: { // xor imm32 with EAX 393 const int32_t arg2 = next32(); -394 trace(90, "run") << "xor imm32 0x" << HEXWORD << arg2 << " with EAX" << end(); +394 trace(90, "run") << "xor imm32 0x" << HEXWORD << arg2 << " with EAX" << end(); 395 BINARY_BITWISE_OP(^, Reg[EAX].i, arg2); 396 break; 397 } @@ -473,9 +468,9 @@ if ('onhashchange' in window) { 406 # ModR/M in binary: 00 (indirect mode) 110 (xor imm32) 011 (dest EBX) 407 == 0x2000 # data segment 408 a0 b0 c0 d0 # 0xd0c0b0a0 -409 +run: combine imm32 with r/m32 +409 +run: combine imm32 with r/m32 410 +run: effective address is 0x00002000 (EBX) -411 +run: imm32 is 0x0d0c0b0a +411 +run: imm32 is 0x0d0c0b0a 412 +run: subop xor 413 +run: storing 0xddccbbaa 414 @@ -492,30 +487,30 @@ if ('onhashchange' in window) { 425 # op ModR/M SIB displacement immediate 426 81 f3 0a 0b 0c 0d # xor 0x0d0c0b0a with EBX 427 # ModR/M in binary: 11 (direct mode) 110 (xor imm32) 011 (dest EBX) -428 +run: combine imm32 with r/m32 +428 +run: combine imm32 with r/m32 429 +run: r/m32 is EBX -430 +run: imm32 is 0x0d0c0b0a +430 +run: imm32 is 0x0d0c0b0a 431 +run: subop xor 432 +run: storing 0xddccbbaa 433 434 //:: compare (cmp) 435 436 :(before "End Initialize Op Names") -437 put_new(Name, "3d", "compare: set SF if EAX < imm32 (cmp)"); +437 put_new(Name, "3d", "compare: set SF if EAX < imm32 (cmp)"); 438 439 :(scenario compare_imm32_with_eax_greater) 440 % Reg[EAX].i = 0x0d0c0b0a; 441 == 0x1 442 # op ModR/M SIB displacement immediate 443 3d 07 0b 0c 0d # compare 0x0d0c0b07 with EAX -444 +run: compare EAX and imm32 0x0d0c0b07 +444 +run: compare EAX and imm32 0x0d0c0b07 445 +run: SF=0; ZF=0; OF=0 446 447 :(before "End Single-Byte Opcodes") 448 case 0x3d: { // compare EAX with imm32 449 const int32_t arg1 = Reg[EAX].i; 450 const int32_t arg2 = next32(); -451 trace(90, "run") << "compare EAX and imm32 0x" << HEXWORD << arg2 << end(); +451 trace(90, "run") << "compare EAX and imm32 0x" << HEXWORD << arg2 << end(); 452 const int32_t tmp1 = arg1 - arg2; 453 SF = (tmp1 < 0); 454 ZF = (tmp1 == 0); @@ -530,7 +525,7 @@ if ('onhashchange' in window) { 463 == 0x1 464 # op ModR/M SIB displacement immediate 465 3d 0a 0b 0c 0d # compare 0x0d0c0b0a with EAX -466 +run: compare EAX and imm32 0x0d0c0b0a +466 +run: compare EAX and imm32 0x0d0c0b0a 467 +run: SF=1; ZF=0; OF=0 468 469 :(scenario compare_imm32_with_eax_equal) @@ -538,7 +533,7 @@ if ('onhashchange' in window) { 471 == 0x1 472 # op ModR/M SIB displacement immediate 473 3d 0a 0b 0c 0d # compare 0x0d0c0b0a with EAX -474 +run: compare EAX and imm32 0x0d0c0b0a +474 +run: compare EAX and imm32 0x0d0c0b0a 475 +run: SF=0; ZF=1; OF=0 476 477 //: @@ -549,9 +544,9 @@ if ('onhashchange' in window) { 482 # op ModR/M SIB displacement immediate 483 81 fb 07 0b 0c 0d # compare 0x0d0c0b07 with EBX 484 # ModR/M in binary: 11 (direct mode) 111 (compare imm32) 011 (dest EBX) -485 +run: combine imm32 with r/m32 +485 +run: combine imm32 with r/m32 486 +run: r/m32 is EBX -487 +run: imm32 is 0x0d0c0b07 +487 +run: imm32 is 0x0d0c0b07 488 +run: SF=0; ZF=0; OF=0 489 490 :(before "End Op 81 Subops") @@ -572,9 +567,9 @@ if ('onhashchange' in window) { 505 # op ModR/M SIB displacement immediate 506 81 fb 0a 0b 0c 0d # compare 0x0d0c0b0a with EBX 507 # ModR/M in binary: 11 (direct mode) 111 (compare imm32) 011 (dest EBX) -508 +run: combine imm32 with r/m32 +508 +run: combine imm32 with r/m32 509 +run: r/m32 is EBX -510 +run: imm32 is 0x0d0c0b0a +510 +run: imm32 is 0x0d0c0b0a 511 +run: SF=1; ZF=0; OF=0 512 513 :(scenario compare_imm32_with_r32_equal) @@ -583,9 +578,9 @@ if ('onhashchange' in window) { 516 # op ModR/M SIB displacement immediate 517 81 fb 0a 0b 0c 0d # compare 0x0d0c0b0a with EBX 518 # ModR/M in binary: 11 (direct mode) 111 (compare imm32) 011 (dest EBX) -519 +run: combine imm32 with r/m32 +519 +run: combine imm32 with r/m32 520 +run: r/m32 is EBX -521 +run: imm32 is 0x0d0c0b0a +521 +run: imm32 is 0x0d0c0b0a 522 +run: SF=0; ZF=1; OF=0 523 524 :(scenario compare_imm32_with_mem_at_r32_greater) @@ -596,9 +591,9 @@ if ('onhashchange' in window) { 529 # ModR/M in binary: 00 (indirect mode) 111 (compare imm32) 011 (dest EBX) 530 == 0x2000 # data segment 531 0a 0b 0c 0d # 0x0d0c0b0a -532 +run: combine imm32 with r/m32 +532 +run: combine imm32 with r/m32 533 +run: effective address is 0x00002000 (EBX) -534 +run: imm32 is 0x0d0c0b07 +534 +run: imm32 is 0x0d0c0b07 535 +run: SF=0; ZF=0; OF=0 536 537 :(scenario compare_imm32_with_mem_at_r32_lesser) @@ -609,9 +604,9 @@ if ('onhashchange' in window) { 542 # ModR/M in binary: 00 (indirect mode) 111 (compare imm32) 011 (dest EBX) 543 == 0x2000 # data segment 544 07 0b 0c 0d # 0x0d0c0b07 -545 +run: combine imm32 with r/m32 +545 +run: combine imm32 with r/m32 546 +run: effective address is 0x00002000 (EBX) -547 +run: imm32 is 0x0d0c0b0a +547 +run: imm32 is 0x0d0c0b0a 548 +run: SF=1; ZF=0; OF=0 549 550 :(scenario compare_imm32_with_mem_at_r32_equal) @@ -623,28 +618,28 @@ if ('onhashchange' in window) { 556 # ModR/M in binary: 00 (indirect mode) 111 (compare imm32) 011 (dest EBX) 557 == 0x2000 # data segment 558 0a 0b 0c 0d # 0x0d0c0b0a -559 +run: combine imm32 with r/m32 +559 +run: combine imm32 with r/m32 560 +run: effective address is 0x00002000 (EBX) -561 +run: imm32 is 0x0d0c0b0a +561 +run: imm32 is 0x0d0c0b0a 562 +run: SF=0; ZF=1; OF=0 563 564 //:: copy (mov) 565 566 :(before "End Initialize Op Names") -567 put_new(Name, "b8", "copy imm32 to EAX (mov)"); -568 put_new(Name, "b9", "copy imm32 to ECX (mov)"); -569 put_new(Name, "ba", "copy imm32 to EDX (mov)"); -570 put_new(Name, "bb", "copy imm32 to EBX (mov)"); -571 put_new(Name, "bc", "copy imm32 to ESP (mov)"); -572 put_new(Name, "bd", "copy imm32 to EBP (mov)"); -573 put_new(Name, "be", "copy imm32 to ESI (mov)"); -574 put_new(Name, "bf", "copy imm32 to EDI (mov)"); +567 put_new(Name, "b8", "copy imm32 to EAX (mov)"); +568 put_new(Name, "b9", "copy imm32 to ECX (mov)"); +569 put_new(Name, "ba", "copy imm32 to EDX (mov)"); +570 put_new(Name, "bb", "copy imm32 to EBX (mov)"); +571 put_new(Name, "bc", "copy imm32 to ESP (mov)"); +572 put_new(Name, "bd", "copy imm32 to EBP (mov)"); +573 put_new(Name, "be", "copy imm32 to ESI (mov)"); +574 put_new(Name, "bf", "copy imm32 to EDI (mov)"); 575 576 :(scenario copy_imm32_to_r32) 577 == 0x1 578 # op ModR/M SIB displacement immediate 579 bb 0a 0b 0c 0d # copy 0x0d0c0b0a to EBX -580 +run: copy imm32 0x0d0c0b0a to EBX +580 +run: copy imm32 0x0d0c0b0a to EBX 581 582 :(before "End Single-Byte Opcodes") 583 case 0xb8: @@ -657,7 +652,7 @@ if ('onhashchange' in window) { 590 case 0xbf: { // copy imm32 to r32 591 const uint8_t rdest = op & 0x7; 592 const int32_t src = next32(); -593 trace(90, "run") << "copy imm32 0x" << HEXWORD << src << " to " << rname(rdest) << end(); +593 trace(90, "run") << "copy imm32 0x" << HEXWORD << src << " to " << rname(rdest) << end(); 594 Reg[rdest].i = src; 595 break; 596 } @@ -665,7 +660,7 @@ if ('onhashchange' in window) { 598 //: 599 600 :(before "End Initialize Op Names") -601 put_new(Name, "c7", "copy imm32 to rm32 (mov)"); +601 put_new(Name, "c7", "copy imm32 to rm32 (mov)"); 602 603 :(scenario copy_imm32_to_mem_at_r32) 604 % Reg[EBX].i = 0x60; @@ -673,45 +668,50 @@ if ('onhashchange' in window) { 606 # op ModR/M SIB displacement immediate 607 c7 03 0a 0b 0c 0d # copy 0x0d0c0b0a to *EBX 608 # ModR/M in binary: 00 (indirect mode) 000 (unused) 011 (dest EBX) -609 +run: copy imm32 to r/m32 +609 +run: copy imm32 to r/m32 610 +run: effective address is 0x00000060 (EBX) -611 +run: imm32 is 0x0d0c0b0a +611 +run: imm32 is 0x0d0c0b0a 612 613 :(before "End Single-Byte Opcodes") 614 case 0xc7: { // copy imm32 to r32 615 const uint8_t modrm = next(); -616 trace(90, "run") << "copy imm32 to r/m32" << end(); -617 int32_t* dest = effective_address(modrm); -618 const int32_t src = next32(); -619 trace(90, "run") << "imm32 is 0x" << HEXWORD << src << end(); -620 *dest = src; -621 break; -622 } -623 -624 //:: push -625 -626 :(before "End Initialize Op Names") -627 put_new(Name, "68", "push imm32 to stack (push)"); +616 trace(90, "run") << "copy imm32 to r/m32" << end(); +617 const uint8_t subop = (modrm>>3)&0x7; // middle 3 'reg opcode' bits +618 if (subop != 0) { +619 cerr << "unrecognized subop for opcode c7: " << NUM(subop) << " (only 0/copy currently implemented)\n"; +620 exit(1); +621 } +622 int32_t* dest = effective_address(modrm); +623 const int32_t src = next32(); +624 trace(90, "run") << "imm32 is 0x" << HEXWORD << src << end(); +625 *dest = src; +626 break; +627 } 628 -629 :(scenario push_imm32) -630 % Reg[ESP].u = 0x14; -631 == 0x1 -632 # op ModR/M SIB displacement immediate -633 68 af 00 00 00 # push *EAX to stack -634 +run: push imm32 0x000000af -635 +run: ESP is now 0x00000010 -636 +run: contents at ESP: 0x000000af -637 -638 :(before "End Single-Byte Opcodes") -639 case 0x68: { -640 const uint32_t val = static_cast<uint32_t>(next32()); -641 trace(90, "run") << "push imm32 0x" << HEXWORD << val << end(); -642 //? cerr << "push: " << val << " => " << Reg[ESP].u << '\n'; -643 push(val); -644 trace(90, "run") << "ESP is now 0x" << HEXWORD << Reg[ESP].u << end(); -645 trace(90, "run") << "contents at ESP: 0x" << HEXWORD << read_mem_u32(Reg[ESP].u) << end(); -646 break; -647 } +629 //:: push +630 +631 :(before "End Initialize Op Names") +632 put_new(Name, "68", "push imm32 to stack (push)"); +633 +634 :(scenario push_imm32) +635 % Reg[ESP].u = 0x14; +636 == 0x1 +637 # op ModR/M SIB displacement immediate +638 68 af 00 00 00 # push *EAX to stack +639 +run: push imm32 0x000000af +640 +run: ESP is now 0x00000010 +641 +run: contents at ESP: 0x000000af +642 +643 :(before "End Single-Byte Opcodes") +644 case 0x68: { +645 const uint32_t val = static_cast<uint32_t>(next32()); +646 trace(90, "run") << "push imm32 0x" << HEXWORD << val << end(); +647 //? cerr << "push: " << val << " => " << Reg[ESP].u << '\n'; +648 push(val); +649 trace(90, "run") << "ESP is now 0x" << HEXWORD << Reg[ESP].u << end(); +650 trace(90, "run") << "contents at ESP: 0x" << HEXWORD << read_mem_u32(Reg[ESP].u) << end(); +651 break; +652 } -- cgit 1.4.1-2-gfad0