From c8a3ccbeb89221d726542a89b42ddb26827af1f4 Mon Sep 17 00:00:00 2001 From: Kartik Agaram Date: Sat, 27 Jul 2019 18:26:18 -0700 Subject: 5490 --- html/015immediate_addressing.cc.html | 228 +++++++++++++++++------------------ 1 file changed, 114 insertions(+), 114 deletions(-) (limited to 'html/015immediate_addressing.cc.html') diff --git a/html/015immediate_addressing.cc.html b/html/015immediate_addressing.cc.html index cbc5d8cc..09fa552d 100644 --- a/html/015immediate_addressing.cc.html +++ b/html/015immediate_addressing.cc.html @@ -2,7 +2,7 @@ -Mu - subx/015immediate_addressing.cc +Mu - 015immediate_addressing.cc @@ -57,17 +57,17 @@ if ('onhashchange' in window) { -https://github.com/akkartik/mu/blob/master/subx/015immediate_addressing.cc +https://github.com/akkartik/mu/blob/master/015immediate_addressing.cc 
    1 //: instructions that (immediately) contain an argument to act with
    2 
    3 :(before "End Initialize Op Names")
-   4 put_new(Name, "05", "add imm32 to EAX (add)");
+   4 put_new(Name, "05", "add imm32 to EAX (add)");
    5 
    6 :(before "End Single-Byte Opcodes")
    7 case 0x05: {  // add imm32 to EAX
-   8   int32_t signed_arg2 = next32();
-   9   trace(Callstack_depth+1, "run") << "add imm32 0x" << HEXWORD << signed_arg2 << " to EAX" << end();
+   8   int32_t signed_arg2 = next32();
+   9   trace(Callstack_depth+1, "run") << "add imm32 0x" << HEXWORD << signed_arg2 << " to EAX" << end();
   10   int32_t signed_result = Reg[EAX].i + signed_arg2;
   11   SF = (signed_result < 0);
   12   ZF = (signed_result == 0);
@@ -80,14 +80,14 @@ if ('onhashchange' in window) {
   19   CF = (unsigned_result != unsigned_full_result);
   20   trace(Callstack_depth+1, "run") << "SF=" << SF << "; ZF=" << ZF << "; CF=" << CF << "; OF=" << OF << end();
   21   Reg[EAX].i = signed_result;
-  22   trace(Callstack_depth+1, "run") << "storing 0x" << HEXWORD << Reg[EAX].i << end();
+  22   trace(Callstack_depth+1, "run") << "storing 0x" << HEXWORD << Reg[EAX].i << end();
   23   break;
   24 }
   25 
   26 :(code)
   27 void test_add_imm32_to_EAX_signed_overflow() {
   28   Reg[EAX].i = 0x7fffffff;  // largest positive signed integer
-  29   run(
+  29   run(
   30       "== code 0x1\n"
   31       // op     ModR/M  SIB   displacement  immediate
   32       "  05                                 01 00 00 00 \n" // add 1 to EAX
@@ -102,7 +102,7 @@ if ('onhashchange' in window) {
   41 void test_add_imm32_to_EAX_unsigned_overflow() {
   42   Reg[EAX].u = 0xffffffff;  // largest unsigned number
   43   Reg[EBX].u = 1;
-  44   run(
+  44   run(
   45       "== code 0x1\n"
   46       // op     ModR/M  SIB   displacement  immediate
   47       "  05                                 01 00 00 00 \n" // add 1 to EAX
@@ -116,7 +116,7 @@ if ('onhashchange' in window) {
   55 
   56 void test_add_imm32_to_EAX_unsigned_and_signed_overflow() {
   57   Reg[EAX].u = 0x80000000;  // smallest negative signed integer
-  58   run(
+  58   run(
   59       "== code 0x1\n"
   60       // op     ModR/M  SIB   displacement  immediate
   61       "  05                                 00 00 00 80 \n" // add 0x80000000 to EAX
@@ -131,12 +131,12 @@ if ('onhashchange' in window) {
   70 //:
   71 
   72 :(before "End Initialize Op Names")
-  73 put_new(Name, "81", "combine rm32 with imm32 based on subop (add/sub/and/or/xor/cmp)");
+  73 put_new(Name, "81", "combine rm32 with imm32 based on subop (add/sub/and/or/xor/cmp)");
   74 
   75 :(code)
   76 void test_add_imm32_to_r32() {
   77   Reg[EBX].i = 1;
-  78   run(
+  78   run(
   79       "== code 0x1\n"
   80       // op     ModR/M  SIB   displacement  immediate
   81       "  81     c3                          0a 0b 0c 0d\n"  // add 0x0d0c0b0a to EBX
@@ -154,10 +154,10 @@ if ('onhashchange' in window) {
   93 :(before "End Single-Byte Opcodes")
   94 case 0x81: {  // combine r/m32 with imm32
   95   trace(Callstack_depth+1, "run") << "combine r/m32 with imm32" << end();
-  96   const uint8_t modrm = next();
+  96   const uint8_t modrm = next();
   97   int32_t* signed_arg1 = effective_address(modrm);
-  98   const int32_t signed_arg2 = next32();
-  99   trace(Callstack_depth+1, "run") << "imm32 is 0x" << HEXWORD << signed_arg2 << end();
+  98   const int32_t signed_arg2 = next32();
+  99   trace(Callstack_depth+1, "run") << "imm32 is 0x" << HEXWORD << signed_arg2 << end();
  100   const uint8_t subop = (modrm>>3)&0x7;  // middle 3 'reg opcode' bits
  101   switch (subop) {
  102   case 0: {
@@ -175,12 +175,12 @@ if ('onhashchange' in window) {
  114     CF = (unsigned_result != unsigned_full_result);
  115     trace(Callstack_depth+1, "run") << "SF=" << SF << "; ZF=" << ZF << "; CF=" << CF << "; OF=" << OF << end();
  116     *signed_arg1 = signed_result;
- 117     trace(Callstack_depth+1, "run") << "storing 0x" << HEXWORD << *signed_arg1 << end();
+ 117     trace(Callstack_depth+1, "run") << "storing 0x" << HEXWORD << *signed_arg1 << end();
  118     break;
  119   }
  120   // End Op 81 Subops
  121   default:
- 122     cerr << "unrecognized subop for opcode 81: " << NUM(subop) << '\n';
+ 122     cerr << "unrecognized subop for opcode 81: " << NUM(subop) << '\n';
  123     exit(1);
  124   }
  125   break;
@@ -189,7 +189,7 @@ if ('onhashchange' in window) {
  128 :(code)
  129 void test_add_imm32_to_r32_signed_overflow() {
  130   Reg[EBX].i = 0x7fffffff;  // largest positive signed integer
- 131   run(
+ 131   run(
  132       "== code 0x1\n"
  133       // op     ModR/M  SIB   displacement  immediate
  134       "  81     c3                          01 00 00 00\n"  // add 1 to EBX
@@ -207,7 +207,7 @@ if ('onhashchange' in window) {
  146 
  147 void test_add_imm32_to_r32_unsigned_overflow() {
  148   Reg[EBX].u = 0xffffffff;  // largest unsigned number
- 149   run(
+ 149   run(
  150       "== code 0x1\n"
  151       // op     ModR/M  SIB   displacement  immediate
  152       "  81     c3                          01 00 00 00\n"  // add 1 to EBX
@@ -225,7 +225,7 @@ if ('onhashchange' in window) {
  164 
  165 void test_add_imm32_to_r32_unsigned_and_signed_overflow() {
  166   Reg[EBX].u = 0x80000000;  // smallest negative signed integer
- 167   run(
+ 167   run(
  168       "== code 0x1\n"
  169       // op     ModR/M  SIB   displacement  immediate
  170       "  81     c3                          00 00 00 80\n"  // add 0x80000000 to EBX
@@ -246,7 +246,7 @@ if ('onhashchange' in window) {
  185 :(code)
  186 void test_add_imm32_to_mem_at_r32() {
  187   Reg[EBX].i = 0x2000;
- 188   run(
+ 188   run(
  189       "== code 0x1\n"
  190       // op     ModR/M  SIB   displacement  immediate
  191       "  81     03                          0a 0b 0c 0d \n"  // add 0x0d0c0b0a to *EBX
@@ -266,12 +266,12 @@ if ('onhashchange' in window) {
  205 //:: subtract
  206 
  207 :(before "End Initialize Op Names")
- 208 put_new(Name, "2d", "subtract imm32 from EAX (sub)");
+ 208 put_new(Name, "2d", "subtract imm32 from EAX (sub)");
  209 
  210 :(code)
  211 void test_subtract_imm32_from_EAX() {
  212   Reg[EAX].i = 0x0d0c0baa;
- 213   run(
+ 213   run(
  214       "== code 0x1\n"
  215       // op     ModR/M  SIB   displacement  immediate
  216       "  2d                                 0a 0b 0c 0d \n"  // subtract 0x0d0c0b0a from EAX
@@ -284,8 +284,8 @@ if ('onhashchange' in window) {
  223 
  224 :(before "End Single-Byte Opcodes")
  225 case 0x2d: {  // subtract imm32 from EAX
- 226   const int32_t signed_arg2 = next32();
- 227   trace(Callstack_depth+1, "run") << "subtract imm32 0x" << HEXWORD << signed_arg2 << " from EAX" << end();
+ 226   const int32_t signed_arg2 = next32();
+ 227   trace(Callstack_depth+1, "run") << "subtract imm32 0x" << HEXWORD << signed_arg2 << " from EAX" << end();
  228   int32_t signed_result = Reg[EAX].i - signed_arg2;
  229   SF = (signed_result < 0);
  230   ZF = (signed_result == 0);
@@ -298,14 +298,14 @@ if ('onhashchange' in window) {
  237   CF = (unsigned_result != unsigned_full_result);
  238   trace(Callstack_depth+1, "run") << "SF=" << SF << "; ZF=" << ZF << "; CF=" << CF << "; OF=" << OF << end();
  239   Reg[EAX].i = signed_result;
- 240   trace(Callstack_depth+1, "run") << "storing 0x" << HEXWORD << Reg[EAX].i << end();
+ 240   trace(Callstack_depth+1, "run") << "storing 0x" << HEXWORD << Reg[EAX].i << end();
  241   break;
  242 }
  243 
  244 :(code)
  245 void test_subtract_imm32_from_EAX_signed_overflow() {
  246   Reg[EAX].i = 0x80000000;  // smallest negative signed integer
- 247   run(
+ 247   run(
  248       "== code 0x1\n"
  249       // op     ModR/M  SIB   displacement  immediate
  250       "  2d                                 ff ff ff 7f \n"  // subtract largest positive signed integer from EAX
@@ -319,7 +319,7 @@ if ('onhashchange' in window) {
  258 
  259 void test_subtract_imm32_from_EAX_unsigned_overflow() {
  260   Reg[EAX].i = 0;
- 261   run(
+ 261   run(
  262       "== code 0x1\n"
  263       // op     ModR/M  SIB   displacement  immediate
  264       "  2d                                 01 00 00 00 \n"  // subtract 1 from EAX
@@ -333,7 +333,7 @@ if ('onhashchange' in window) {
  272 
  273 void test_subtract_imm32_from_EAX_signed_and_unsigned_overflow() {
  274   Reg[EAX].i = 0;
- 275   run(
+ 275   run(
  276       "== code 0x1\n"
  277       // op     ModR/M  SIB   displacement  immediate
  278       "  2d                                 00 00 00 80 \n"  // subtract smallest negative signed integer from EAX
@@ -349,7 +349,7 @@ if ('onhashchange' in window) {
  288 
  289 void test_subtract_imm32_from_mem_at_r32() {
  290   Reg[EBX].i = 0x2000;
- 291   run(
+ 291   run(
  292       "== code 0x1\n"
  293       // op     ModR/M  SIB   displacement  immediate
  294       "  81     2b                          01 00 00 00 \n"  // subtract 1 from *EBX
@@ -382,14 +382,14 @@ if ('onhashchange' in window) {
  321   CF = (unsigned_result != unsigned_full_result);
  322   trace(Callstack_depth+1, "run") << "SF=" << SF << "; ZF=" << ZF << "; CF=" << CF << "; OF=" << OF << end();
  323   *signed_arg1 = signed_result;
- 324   trace(Callstack_depth+1, "run") << "storing 0x" << HEXWORD << *signed_arg1 << end();
+ 324   trace(Callstack_depth+1, "run") << "storing 0x" << HEXWORD << *signed_arg1 << end();
  325   break;
  326 }
  327 
  328 :(code)
  329 void test_subtract_imm32_from_mem_at_r32_signed_overflow() {
  330   Reg[EBX].i = 0x2000;
- 331   run(
+ 331   run(
  332       "== code 0x1\n"
  333       // op     ModR/M  SIB   displacement  immediate
  334       "  81     2b                          ff ff ff 7f \n"  // subtract largest positive signed integer from *EBX
@@ -410,7 +410,7 @@ if ('onhashchange' in window) {
  349 
  350 void test_subtract_imm32_from_mem_at_r32_unsigned_overflow() {
  351   Reg[EBX].i = 0x2000;
- 352   run(
+ 352   run(
  353       "== code 0x1\n"
  354       // op     ModR/M  SIB   displacement  immediate
  355       "  81     2b                          01 00 00 00 \n"  // subtract 1 from *EBX
@@ -431,7 +431,7 @@ if ('onhashchange' in window) {
  370 
  371 void test_subtract_imm32_from_mem_at_r32_signed_and_unsigned_overflow() {
  372   Reg[EBX].i = 0x2000;
- 373   run(
+ 373   run(
  374       "== code 0x1\n"
  375       // op     ModR/M  SIB   displacement  immediate
  376       "  81     2b                          00 00 00 80 \n"  // subtract smallest negative signed integer from *EBX
@@ -454,7 +454,7 @@ if ('onhashchange' in window) {
  393 
  394 void test_subtract_imm32_from_r32() {
  395   Reg[EBX].i = 10;
- 396   run(
+ 396   run(
  397       "== code 0x1\n"
  398       // op     ModR/M  SIB   displacement  immediate
  399       "  81     eb                          01 00 00 00 \n"  // subtract 1 from EBX
@@ -472,12 +472,12 @@ if ('onhashchange' in window) {
  411 //:: shift left
  412 
  413 :(before "End Initialize Op Names")
- 414 put_new(Name, "c1", "shift rm32 by imm8 bits depending on subop (sal/sar/shl/shr)");
+ 414 put_new(Name, "c1", "shift rm32 by imm8 bits depending on subop (sal/sar/shl/shr)");
  415 
  416 :(code)
  417 void test_shift_left_r32_with_imm8() {
  418   Reg[EBX].i = 13;
- 419   run(
+ 419   run(
  420       "== code 0x1\n"
  421       // op     ModR/M  SIB   displacement  immediate
  422       "  c1     e3                          01          \n"  // shift EBX left by 1 bit
@@ -493,14 +493,14 @@ if ('onhashchange' in window) {
  432 
  433 :(before "End Single-Byte Opcodes")
  434 case 0xc1: {
- 435   const uint8_t modrm = next();
+ 435   const uint8_t modrm = next();
  436   trace(Callstack_depth+1, "run") << "operate on r/m32" << end();
  437   int32_t* arg1 = effective_address(modrm);
  438   const uint8_t subop = (modrm>>3)&0x7;  // middle 3 'reg opcode' bits
  439   switch (subop) {
  440   case 4: {  // shift left r/m32 by CL
  441     trace(Callstack_depth+1, "run") << "subop: shift left by CL bits" << end();
- 442     uint8_t count = next() & 0x1f;
+ 442     uint8_t count = next() & 0x1f;
  443     // OF is only defined if count is 1
  444     if (count == 1) {
  445       bool msb = (*arg1 & 0x80000000) >> 1;
@@ -512,12 +512,12 @@ if ('onhashchange' in window) {
  451     SF = (*arg1 < 0);
  452     // CF undefined
  453     trace(Callstack_depth+1, "run") << "SF=" << SF << "; ZF=" << ZF << "; CF=" << CF << "; OF=" << OF << end();
- 454     trace(Callstack_depth+1, "run") << "storing 0x" << HEXWORD << *arg1 << end();
+ 454     trace(Callstack_depth+1, "run") << "storing 0x" << HEXWORD << *arg1 << end();
  455     break;
  456   }
  457   // End Op c1 Subops
  458   default:
- 459     cerr << "unrecognized subop for opcode c1: " << NUM(subop) << '\n';
+ 459     cerr << "unrecognized subop for opcode c1: " << NUM(subop) << '\n';
  460     exit(1);
  461   }
  462   break;
@@ -528,7 +528,7 @@ if ('onhashchange' in window) {
  467 :(code)
  468 void test_shift_right_arithmetic_r32_with_imm8() {
  469   Reg[EBX].i = 26;
- 470   run(
+ 470   run(
  471       "== code 0x1\n"
  472       // op     ModR/M  SIB   displacement  immediate
  473       "  c1     fb                          01          \n"  // shift EBX right by 1 bit
@@ -545,7 +545,7 @@ if ('onhashchange' in window) {
  484 :(before "End Op c1 Subops")
  485 case 7: {  // shift right r/m32 by CL, preserving sign
  486   trace(Callstack_depth+1, "run") << "subop: shift right by CL bits, while preserving sign" << end();
- 487   uint8_t count = next() & 0x1f;
+ 487   uint8_t count = next() & 0x1f;
  488   int32_t result = (*arg1 >> count);
  489   ZF = (*arg1 == 0);
  490   SF = (*arg1 < 0);
@@ -555,14 +555,14 @@ if ('onhashchange' in window) {
  494   CF = ((*arg1 >> (count-1)) & 0x1);
  495   trace(Callstack_depth+1, "run") << "SF=" << SF << "; ZF=" << ZF << "; CF=" << CF << "; OF=" << OF << end();
  496   *arg1 = result;
- 497   trace(Callstack_depth+1, "run") << "storing 0x" << HEXWORD << *arg1 << end();
+ 497   trace(Callstack_depth+1, "run") << "storing 0x" << HEXWORD << *arg1 << end();
  498   break;
  499 }
  500 
  501 :(code)
  502 void test_shift_right_arithmetic_odd_r32_with_imm8() {
  503   Reg[EBX].i = 27;
- 504   run(
+ 504   run(
  505       "== code 0x1\n"
  506       // op     ModR/M  SIB   displacement  immediate
  507       "  c1     fb                          01          \n"  // shift EBX right by 1 bit
@@ -580,7 +580,7 @@ if ('onhashchange' in window) {
  519 :(code)
  520 void test_shift_right_arithmetic_negative_r32_with_imm8() {
  521   Reg[EBX].i = 0xfffffffd;  // -3
- 522   run(
+ 522   run(
  523       "== code 0x1\n"
  524       // op     ModR/M  SIB   displacement  immediate
  525       "  c1     fb                          01          \n"  // shift EBX right by 1 bit, while preserving sign
@@ -600,7 +600,7 @@ if ('onhashchange' in window) {
  539 :(code)
  540 void test_shift_right_logical_r32_with_imm8() {
  541   Reg[EBX].i = 26;
- 542   run(
+ 542   run(
  543       "== code 0x1\n"
  544       // op     ModR/M  SIB   displacement  immediate
  545       "  c1     eb                          01          \n"  // shift EBX right by 1 bit, while padding zeroes
@@ -617,7 +617,7 @@ if ('onhashchange' in window) {
  556 :(before "End Op c1 Subops")
  557 case 5: {  // shift right r/m32 by CL, preserving sign
  558   trace(Callstack_depth+1, "run") << "subop: shift right by CL bits, while padding zeroes" << end();
- 559   uint8_t count = next() & 0x1f;
+ 559   uint8_t count = next() & 0x1f;
  560   // OF is only defined if count is 1
  561   if (count == 1) {
  562     bool msb = (*arg1 & 0x80000000) >> 1;
@@ -631,14 +631,14 @@ if ('onhashchange' in window) {
  570   SF = false;
  571   // CF undefined
  572   trace(Callstack_depth+1, "run") << "SF=" << SF << "; ZF=" << ZF << "; CF=" << CF << "; OF=" << OF << end();
- 573   trace(Callstack_depth+1, "run") << "storing 0x" << HEXWORD << *arg1 << end();
+ 573   trace(Callstack_depth+1, "run") << "storing 0x" << HEXWORD << *arg1 << end();
  574   break;
  575 }
  576 
  577 :(code)
  578 void test_shift_right_logical_odd_r32_with_imm8() {
  579   Reg[EBX].i = 27;
- 580   run(
+ 580   run(
  581       "== code 0x1\n"
  582       // op     ModR/M  SIB   displacement  immediate
  583       "  c1     eb                          01          \n"  // shift EBX right by 1 bit, while padding zeroes
@@ -655,7 +655,7 @@ if ('onhashchange' in window) {
  594 :(code)
  595 void test_shift_right_logical_negative_r32_with_imm8() {
  596   Reg[EBX].i = 0xfffffffd;
- 597   run(
+ 597   run(
  598       "== code 0x1\n"
  599       // op     ModR/M  SIB   displacement  immediate
  600       "  c1     eb                          01          \n"  // shift EBX right by 1 bit, while padding zeroes
@@ -672,12 +672,12 @@ if ('onhashchange' in window) {
  611 //:: and
  612 
  613 :(before "End Initialize Op Names")
- 614 put_new(Name, "25", "EAX = bitwise AND of imm32 with EAX (and)");
+ 614 put_new(Name, "25", "EAX = bitwise AND of imm32 with EAX (and)");
  615 
  616 :(code)
  617 void test_and_EAX_with_imm32() {
  618   Reg[EAX].i = 0xff;
- 619   run(
+ 619   run(
  620       "== code 0x1\n"
  621       // op     ModR/M  SIB   displacement  immediate
  622       "  25                                 0a 0b 0c 0d \n"  // and 0x0d0c0b0a with EAX
@@ -692,10 +692,10 @@ if ('onhashchange' in window) {
  631 case 0x25: {  // and imm32 with EAX
  632   // bitwise ops technically operate on unsigned numbers, but it makes no
  633   // difference
- 634   const int32_t signed_arg2 = next32();
- 635   trace(Callstack_depth+1, "run") << "and imm32 0x" << HEXWORD << signed_arg2 << " with EAX" << end();
+ 634   const int32_t signed_arg2 = next32();
+ 635   trace(Callstack_depth+1, "run") << "and imm32 0x" << HEXWORD << signed_arg2 << " with EAX" << end();
  636   Reg[EAX].i &= signed_arg2;
- 637   trace(Callstack_depth+1, "run") << "storing 0x" << HEXWORD << Reg[EAX].i << end();
+ 637   trace(Callstack_depth+1, "run") << "storing 0x" << HEXWORD << Reg[EAX].i << end();
  638   SF = (Reg[EAX].i >> 31);
  639   ZF = (Reg[EAX].i == 0);
  640   CF = false;
@@ -709,7 +709,7 @@ if ('onhashchange' in window) {
  648 :(code)
  649 void test_and_imm32_with_mem_at_r32() {
  650   Reg[EBX].i = 0x2000;
- 651   run(
+ 651   run(
  652       "== code 0x1\n"
  653       // op     ModR/M  SIB   displacement  immediate
  654       "  81     23                          0a 0b 0c 0d \n"  // and 0x0d0c0b0a with *EBX
@@ -732,7 +732,7 @@ if ('onhashchange' in window) {
  671   // bitwise ops technically operate on unsigned numbers, but it makes no
  672   // difference
  673   *signed_arg1 &= signed_arg2;
- 674   trace(Callstack_depth+1, "run") << "storing 0x" << HEXWORD << *signed_arg1 << end();
+ 674   trace(Callstack_depth+1, "run") << "storing 0x" << HEXWORD << *signed_arg1 << end();
  675   SF = (*signed_arg1 >> 31);
  676   ZF = (*signed_arg1 == 0);
  677   CF = false;
@@ -746,7 +746,7 @@ if ('onhashchange' in window) {
  685 :(code)
  686 void test_and_imm32_with_r32() {
  687   Reg[EBX].i = 0xff;
- 688   run(
+ 688   run(
  689       "== code 0x1\n"
  690       // op     ModR/M  SIB   displacement  immediate
  691       "  81     e3                          0a 0b 0c 0d \n"  // and 0x0d0c0b0a with EBX
@@ -764,12 +764,12 @@ if ('onhashchange' in window) {
  703 //:: or
  704 
  705 :(before "End Initialize Op Names")
- 706 put_new(Name, "0d", "EAX = bitwise OR of imm32 with EAX (or)");
+ 706 put_new(Name, "0d", "EAX = bitwise OR of imm32 with EAX (or)");
  707 
  708 :(code)
  709 void test_or_EAX_with_imm32() {
  710   Reg[EAX].i = 0xd0c0b0a0;
- 711   run(
+ 711   run(
  712       "== code 0x1\n"
  713       // op     ModR/M  SIB   displacement  immediate
  714       "  0d                                 0a 0b 0c 0d \n"  // or 0x0d0c0b0a with EAX
@@ -784,10 +784,10 @@ if ('onhashchange' in window) {
  723 case 0x0d: {  // or imm32 with EAX
  724   // bitwise ops technically operate on unsigned numbers, but it makes no
  725   // difference
- 726   const int32_t signed_arg2 = next32();
- 727   trace(Callstack_depth+1, "run") << "or imm32 0x" << HEXWORD << signed_arg2 << " with EAX" << end();
+ 726   const int32_t signed_arg2 = next32();
+ 727   trace(Callstack_depth+1, "run") << "or imm32 0x" << HEXWORD << signed_arg2 << " with EAX" << end();
  728   Reg[EAX].i |= signed_arg2;
- 729   trace(Callstack_depth+1, "run") << "storing 0x" << HEXWORD << Reg[EAX].i << end();
+ 729   trace(Callstack_depth+1, "run") << "storing 0x" << HEXWORD << Reg[EAX].i << end();
  730   SF = (Reg[EAX].i >> 31);
  731   ZF = (Reg[EAX].i == 0);
  732   CF = false;
@@ -801,7 +801,7 @@ if ('onhashchange' in window) {
  740 :(code)
  741 void test_or_imm32_with_mem_at_r32() {
  742   Reg[EBX].i = 0x2000;
- 743   run(
+ 743   run(
  744       "== code 0x1\n"
  745       // op     ModR/M  SIB   displacement  immediate
  746       "  81     0b                          0a 0b 0c 0d \n"  // or 0x0d0c0b0a with *EBX
@@ -824,7 +824,7 @@ if ('onhashchange' in window) {
  763   // bitwise ops technically operate on unsigned numbers, but it makes no
  764   // difference
  765   *signed_arg1 |= signed_arg2;
- 766   trace(Callstack_depth+1, "run") << "storing 0x" << HEXWORD << *signed_arg1 << end();
+ 766   trace(Callstack_depth+1, "run") << "storing 0x" << HEXWORD << *signed_arg1 << end();
  767   SF = (*signed_arg1 >> 31);
  768   ZF = (*signed_arg1 == 0);
  769   CF = false;
@@ -836,7 +836,7 @@ if ('onhashchange' in window) {
  775 :(code)
  776 void test_or_imm32_with_r32() {
  777   Reg[EBX].i = 0xd0c0b0a0;
- 778   run(
+ 778   run(
  779       "== code 0x1\n"
  780       // op     ModR/M  SIB   displacement  immediate
  781       "  81     cb                          0a 0b 0c 0d \n"  // or 0x0d0c0b0a with EBX
@@ -854,12 +854,12 @@ if ('onhashchange' in window) {
  793 //:: xor
  794 
  795 :(before "End Initialize Op Names")
- 796 put_new(Name, "35", "EAX = bitwise XOR of imm32 with EAX (xor)");
+ 796 put_new(Name, "35", "EAX = bitwise XOR of imm32 with EAX (xor)");
  797 
  798 :(code)
  799 void test_xor_EAX_with_imm32() {
  800   Reg[EAX].i = 0xddccb0a0;
- 801   run(
+ 801   run(
  802       "== code 0x1\n"
  803       // op     ModR/M  SIB   displacement  immediate
  804       "  35                                 0a 0b 0c 0d \n"  // xor 0x0d0c0b0a with EAX
@@ -874,10 +874,10 @@ if ('onhashchange' in window) {
  813 case 0x35: {  // xor imm32 with EAX
  814   // bitwise ops technically operate on unsigned numbers, but it makes no
  815   // difference
- 816   const int32_t signed_arg2 = next32();
- 817   trace(Callstack_depth+1, "run") << "xor imm32 0x" << HEXWORD << signed_arg2 << " with EAX" << end();
+ 816   const int32_t signed_arg2 = next32();
+ 817   trace(Callstack_depth+1, "run") << "xor imm32 0x" << HEXWORD << signed_arg2 << " with EAX" << end();
  818   Reg[EAX].i ^= signed_arg2;
- 819   trace(Callstack_depth+1, "run") << "storing 0x" << HEXWORD << Reg[EAX].i << end();
+ 819   trace(Callstack_depth+1, "run") << "storing 0x" << HEXWORD << Reg[EAX].i << end();
  820   SF = (Reg[EAX].i >> 31);
  821   ZF = (Reg[EAX].i == 0);
  822   CF = false;
@@ -891,7 +891,7 @@ if ('onhashchange' in window) {
  830 :(code)
  831 void test_xor_imm32_with_mem_at_r32() {
  832   Reg[EBX].i = 0x2000;
- 833   run(
+ 833   run(
  834       "== code 0x1\n"
  835       // op     ModR/M  SIB   displacement  immediate
  836       "  81     33                          0a 0b 0c 0d \n"  // xor 0x0d0c0b0a with *EBX
@@ -914,7 +914,7 @@ if ('onhashchange' in window) {
  853   // bitwise ops technically operate on unsigned numbers, but it makes no
  854   // difference
  855   *signed_arg1 ^= signed_arg2;
- 856   trace(Callstack_depth+1, "run") << "storing 0x" << HEXWORD << *signed_arg1 << end();
+ 856   trace(Callstack_depth+1, "run") << "storing 0x" << HEXWORD << *signed_arg1 << end();
  857   SF = (*signed_arg1 >> 31);
  858   ZF = (*signed_arg1 == 0);
  859   CF = false;
@@ -926,7 +926,7 @@ if ('onhashchange' in window) {
  865 :(code)
  866 void test_xor_imm32_with_r32() {
  867   Reg[EBX].i = 0xd0c0b0a0;
- 868   run(
+ 868   run(
  869       "== code 0x1\n"
  870       // op     ModR/M  SIB   displacement  immediate
  871       "  81     f3                          0a 0b 0c 0d \n"  // xor 0x0d0c0b0a with EBX
@@ -944,12 +944,12 @@ if ('onhashchange' in window) {
  883 //:: compare (cmp)
  884 
  885 :(before "End Initialize Op Names")
- 886 put_new(Name, "3d", "compare: set SF if EAX < imm32 (cmp)");
+ 886 put_new(Name, "3d", "compare: set SF if EAX < imm32 (cmp)");
  887 
  888 :(code)
  889 void test_compare_EAX_with_imm32_greater() {
  890   Reg[EAX].i = 0x0d0c0b0a;
- 891   run(
+ 891   run(
  892       "== code 0x1\n"
  893       // op     ModR/M  SIB   displacement  immediate
  894       "  3d                                 07 0b 0c 0d \n"  // compare EAX with 0x0d0c0b07
@@ -963,8 +963,8 @@ if ('onhashchange' in window) {
  902 :(before "End Single-Byte Opcodes")
  903 case 0x3d: {  // compare EAX with imm32
  904   const int32_t signed_arg1 = Reg[EAX].i;
- 905   const int32_t signed_arg2 = next32();
- 906   trace(Callstack_depth+1, "run") << "compare EAX with imm32 0x" << HEXWORD << signed_arg2 << end();
+ 905   const int32_t signed_arg2 = next32();
+ 906   trace(Callstack_depth+1, "run") << "compare EAX with imm32 0x" << HEXWORD << signed_arg2 << end();
  907   const int32_t signed_difference = signed_arg1 - signed_arg2;
  908   SF = (signed_difference < 0);
  909   ZF = (signed_difference == 0);
@@ -982,7 +982,7 @@ if ('onhashchange' in window) {
  921 :(code)
  922 void test_compare_EAX_with_imm32_lesser_unsigned_and_signed() {
  923   Reg[EAX].i = 0x0a0b0c07;
- 924   run(
+ 924   run(
  925       "== code 0x1\n"
  926       // op     ModR/M  SIB   displacement  immediate
  927       "  3d                                 0d 0c 0b 0a \n"  // compare EAX with imm32
@@ -995,7 +995,7 @@ if ('onhashchange' in window) {
  934 
  935 void test_compare_EAX_with_imm32_lesser_unsigned_and_signed_due_to_overflow() {
  936   Reg[EAX].i = 0x7fffffff;  // largest positive signed integer
- 937   run(
+ 937   run(
  938       "== code 0x1\n"
  939       // op     ModR/M  SIB   displacement  immediate
  940       "  3d                                 00 00 00 80\n"  // compare EAX with smallest negative signed integer
@@ -1008,7 +1008,7 @@ if ('onhashchange' in window) {
  947 
  948 void test_compare_EAX_with_imm32_lesser_signed() {
  949   Reg[EAX].i = 0xffffffff;  // -1
- 950   run(
+ 950   run(
  951       "== code 0x1\n"
  952       // op     ModR/M  SIB   displacement  immediate
  953       "  3d                                 01 00 00 00\n"  // compare EAX with 1
@@ -1021,7 +1021,7 @@ if ('onhashchange' in window) {
  960 
  961 void test_compare_EAX_with_imm32_lesser_unsigned() {
  962   Reg[EAX].i = 0x00000001;  // 1
- 963   run(
+ 963   run(
  964       "== code 0x1\n"
  965       // op     ModR/M  SIB   displacement  immediate
  966       "  3d                                 ff ff ff ff\n"  // compare EAX with -1
@@ -1034,7 +1034,7 @@ if ('onhashchange' in window) {
  973 
  974 void test_compare_EAX_with_imm32_equal() {
  975   Reg[EAX].i = 0x0d0c0b0a;
- 976   run(
+ 976   run(
  977       "== code 0x1\n"
  978       // op     ModR/M  SIB   displacement  immediate
  979       "  3d                                 0a 0b 0c 0d \n"  // compare 0x0d0c0b0a with EAX
@@ -1049,7 +1049,7 @@ if ('onhashchange' in window) {
  988 
  989 void test_compare_imm32_with_r32_greater() {
  990   Reg[EBX].i = 0x0d0c0b0a;
- 991   run(
+ 991   run(
  992       "== code 0x1\n"
  993       // op     ModR/M  SIB   displacement  immediate
  994       "  81     fb                          07 0b 0c 0d \n"  // compare 0x0d0c0b07 with EBX
@@ -1083,7 +1083,7 @@ if ('onhashchange' in window) {
 1022 :(code)
 1023 void test_compare_rm32_with_imm32_lesser_unsigned_and_signed() {
 1024   Reg[EAX].i = 0x0a0b0c07;
-1025   run(
+1025   run(
 1026       "== code 0x1\n"
 1027       // op     ModR/M  SIB   displacement  immediate
 1028       "  81     f8                          0d 0c 0b 0a \n"  // compare EAX with imm32
@@ -1100,7 +1100,7 @@ if ('onhashchange' in window) {
 1039 
 1040 void test_compare_rm32_with_imm32_lesser_unsigned_and_signed_due_to_overflow() {
 1041   Reg[EAX].i = 0x7fffffff;  // largest positive signed integer
-1042   run(
+1042   run(
 1043       "== code 0x1\n"
 1044       // op     ModR/M  SIB   displacement  immediate
 1045       "  81     f8                          00 00 00 80\n"  // compare EAX with smallest negative signed integer
@@ -1117,7 +1117,7 @@ if ('onhashchange' in window) {
 1056 
 1057 void test_compare_rm32_with_imm32_lesser_signed() {
 1058   Reg[EAX].i = 0xffffffff;  // -1
-1059   run(
+1059   run(
 1060       "== code 0x1\n"
 1061       // op     ModR/M  SIB   displacement  immediate
 1062       "  81     f8                          01 00 00 00\n"  // compare EAX with 1
@@ -1134,7 +1134,7 @@ if ('onhashchange' in window) {
 1073 
 1074 void test_compare_rm32_with_imm32_lesser_unsigned() {
 1075   Reg[EAX].i = 0x00000001;  // 1
-1076   run(
+1076   run(
 1077       "== code 0x1\n"
 1078       // op     ModR/M  SIB   displacement  immediate
 1079       "  81     f8                          ff ff ff ff\n"  // compare EAX with -1
@@ -1152,7 +1152,7 @@ if ('onhashchange' in window) {
 1091 :(code)
 1092 void test_compare_imm32_with_r32_equal() {
 1093   Reg[EBX].i = 0x0d0c0b0a;
-1094   run(
+1094   run(
 1095       "== code 0x1\n"
 1096       // op     ModR/M  SIB   displacement  immediate
 1097       "  81     fb                          0a 0b 0c 0d \n"  // compare 0x0d0c0b0a with EBX
@@ -1169,7 +1169,7 @@ if ('onhashchange' in window) {
 1108 :(code)
 1109 void test_compare_imm32_with_mem_at_r32_greater() {
 1110   Reg[EBX].i = 0x2000;
-1111   run(
+1111   run(
 1112       "== code 0x1\n"
 1113       // op     ModR/M  SIB   displacement  immediate
 1114       "  81     3b                          07 0b 0c 0d \n"  // compare 0x0d0c0b07 with *EBX
@@ -1188,7 +1188,7 @@ if ('onhashchange' in window) {
 1127 :(code)
 1128 void test_compare_imm32_with_mem_at_r32_lesser() {
 1129   Reg[EAX].i = 0x2000;
-1130   run(
+1130   run(
 1131       "== code 0x1\n"
 1132       // op     ModR/M  SIB   displacement  immediate
 1133       "  81     38                          0a 0b 0c 0d \n"  // compare 0x0d0c0b0a with *EAX
@@ -1208,7 +1208,7 @@ if ('onhashchange' in window) {
 1147 void test_compare_imm32_with_mem_at_r32_equal() {
 1148   Reg[EBX].i = 0x0d0c0b0a;
 1149   Reg[EBX].i = 0x2000;
-1150   run(
+1150   run(
 1151       "== code 0x1\n"
 1152       // op     ModR/M  SIB   displacement  immediate
 1153       "  81     3b                          0a 0b 0c 0d \n"  // compare 0x0d0c0b0a with *EBX
@@ -1228,17 +1228,17 @@ if ('onhashchange' in window) {
 1167 
 1168 :(before "End Initialize Op Names")
 1169 // b8 defined earlier to copy imm32 to EAX
-1170 put_new(Name, "b9", "copy imm32 to ECX (mov)");
-1171 put_new(Name, "ba", "copy imm32 to EDX (mov)");
-1172 put_new(Name, "bb", "copy imm32 to EBX (mov)");
-1173 put_new(Name, "bc", "copy imm32 to ESP (mov)");
-1174 put_new(Name, "bd", "copy imm32 to EBP (mov)");
-1175 put_new(Name, "be", "copy imm32 to ESI (mov)");
-1176 put_new(Name, "bf", "copy imm32 to EDI (mov)");
+1170 put_new(Name, "b9", "copy imm32 to ECX (mov)");
+1171 put_new(Name, "ba", "copy imm32 to EDX (mov)");
+1172 put_new(Name, "bb", "copy imm32 to EBX (mov)");
+1173 put_new(Name, "bc", "copy imm32 to ESP (mov)");
+1174 put_new(Name, "bd", "copy imm32 to EBP (mov)");
+1175 put_new(Name, "be", "copy imm32 to ESI (mov)");
+1176 put_new(Name, "bf", "copy imm32 to EDI (mov)");
 1177 
 1178 :(code)
 1179 void test_copy_imm32_to_r32() {
-1180   run(
+1180   run(
 1181       "== code 0x1\n"
 1182       // op     ModR/M  SIB   displacement  immediate
 1183       "  bb                                 0a 0b 0c 0d \n"  // copy 0x0d0c0b0a to EBX
@@ -1257,8 +1257,8 @@ if ('onhashchange' in window) {
 1196 case 0xbe:
 1197 case 0xbf: {  // copy imm32 to r32
 1198   const uint8_t rdest = op & 0x7;
-1199   const int32_t src = next32();
-1200   trace(Callstack_depth+1, "run") << "copy imm32 0x" << HEXWORD << src << " to " << rname(rdest) << end();
+1199   const int32_t src = next32();
+1200   trace(Callstack_depth+1, "run") << "copy imm32 0x" << HEXWORD << src << " to " << rname(rdest) << end();
 1201   Reg[rdest].i = src;
 1202   break;
 1203 }
@@ -1266,12 +1266,12 @@ if ('onhashchange' in window) {
 1205 //:
 1206 
 1207 :(before "End Initialize Op Names")
-1208 put_new(Name, "c7", "copy imm32 to rm32 (mov)");
+1208 put_new(Name, "c7", "copy imm32 to rm32 (mov)");
 1209 
 1210 :(code)
 1211 void test_copy_imm32_to_mem_at_r32() {
 1212   Reg[EBX].i = 0x60;
-1213   run(
+1213   run(
 1214       "== code 0x1\n"
 1215       // op     ModR/M  SIB   displacement  immediate
 1216       "  c7     03                          0a 0b 0c 0d \n"  // copy 0x0d0c0b0a to *EBX
@@ -1286,16 +1286,16 @@ if ('onhashchange' in window) {
 1225 
 1226 :(before "End Single-Byte Opcodes")
 1227 case 0xc7: {  // copy imm32 to r32
-1228   const uint8_t modrm = next();
+1228   const uint8_t modrm = next();
 1229   trace(Callstack_depth+1, "run") << "copy imm32 to r/m32" << end();
 1230   const uint8_t subop = (modrm>>3)&0x7;  // middle 3 'reg opcode' bits
 1231   if (subop != 0) {
-1232     cerr << "unrecognized subop for opcode c7: " << NUM(subop) << " (only 0/copy currently implemented)\n";
+1232     cerr << "unrecognized subop for opcode c7: " << NUM(subop) << " (only 0/copy currently implemented)\n";
 1233     exit(1);
 1234   }
 1235   int32_t* dest = effective_address(modrm);
-1236   const int32_t src = next32();
-1237   trace(Callstack_depth+1, "run") << "imm32 is 0x" << HEXWORD << src << end();
+1236   const int32_t src = next32();
+1237   trace(Callstack_depth+1, "run") << "imm32 is 0x" << HEXWORD << src << end();
 1238   *dest = src;
 1239   break;
 1240 }
@@ -1303,13 +1303,13 @@ if ('onhashchange' in window) {
 1242 //:: push
 1243 
 1244 :(before "End Initialize Op Names")
-1245 put_new(Name, "68", "push imm32 to stack (push)");
+1245 put_new(Name, "68", "push imm32 to stack (push)");
 1246 
 1247 :(code)
 1248 void test_push_imm32() {
 1249   Mem.push_back(vma(0xbd000000));  // manually allocate memory
 1250   Reg[ESP].u = 0xbd000014;
-1251   run(
+1251   run(
 1252       "== code 0x1\n"
 1253       // op     ModR/M  SIB   displacement  immediate
 1254       "  68                                 af 00 00 00 \n"  // push *EAX to stack
@@ -1323,12 +1323,12 @@ if ('onhashchange' in window) {
 1262 
 1263 :(before "End Single-Byte Opcodes")
 1264 case 0x68: {
-1265   const uint32_t val = static_cast<uint32_t>(next32());
-1266   trace(Callstack_depth+1, "run") << "push imm32 0x" << HEXWORD << val << end();
+1265   const uint32_t val = static_cast<uint32_t>(next32());
+1266   trace(Callstack_depth+1, "run") << "push imm32 0x" << HEXWORD << val << end();
 1267 //?   cerr << "push: " << val << " => " << Reg[ESP].u << '\n';
 1268   push(val);
-1269   trace(Callstack_depth+1, "run") << "ESP is now 0x" << HEXWORD << Reg[ESP].u << end();
-1270   trace(Callstack_depth+1, "run") << "contents at ESP: 0x" << HEXWORD << read_mem_u32(Reg[ESP].u) << end();
+1269   trace(Callstack_depth+1, "run") << "ESP is now 0x" << HEXWORD << Reg[ESP].u << end();
+1270   trace(Callstack_depth+1, "run") << "contents at ESP: 0x" << HEXWORD << read_mem_u32(Reg[ESP].u) << end();
 1271   break;
 1272 }
-- cgit 1.4.1-2-gfad0