1 //: operating on memory at the address provided by some register
  2 
  3 :(scenario add_r32_to_mem_at_r32)
  4 % Reg[3].i = 0x10;
  5 % Reg[0].i = 0x60;
  6 # word in addresses 0x60-0x63 has value 1
  7 % Mem.at(0x60) = 1;
  8 # op  ModR/M  SIB   displacement  immediate
  9   01  18                                     # add EBX (reg 3) to *EAX (reg 0)
 10 +run: add reg 3 to effective address
 11 +run: effective address is mem at address 0x60 (reg 0)
 12 +run: storing 0x00000011
 13 
 14 :(before "End Mod Special-cases")
 15 case 0:
 16   // mod 0 is usually indirect addressing
 17   switch (rm) {
 18   default:
 19   ¦ trace(2, "run") << "effective address is mem at address 0x" << std::hex << Reg[rm].u << " (reg " << NUM(rm) << ")" << end();
 20   ¦ assert(Reg[rm].u + sizeof(int32_t) <= Mem.size());
 21   ¦ result = reinterpret_cast<int32_t*>(&Mem.at(Reg[rm].u));  // rely on the host itself being in little-endian order
 22   ¦ break;
 23   // End Mod 0 Special-cases
 24   }
 25   break;
 26 
 27 //:
 28 
 29 :(scenario add_mem_at_r32_to_r32)
 30 % Reg[0].i = 0x60;
 31 % Reg[3].i = 0x10;
 32 % Mem.at(0x60) = 1;
 33 # op  ModR/M  SIB   displacement  immediate
 34   03  18                                      # add *EAX (reg 0) to EBX (reg 3)
 35 +run: add effective address to reg 3
 36 +run: effective address is mem at address 0x60 (reg 0)
 37 +run: storing 0x00000011
 38 
 39 :(before "End Single-Byte Opcodes")
 40 case 0x03: {  // add r/m32 to r32
 41   uint8_t modrm = next();
 42   uint8_t arg1 = (modrm>>3)&0x7;
 43   trace(2, "run") << "add effective address to reg " << NUM(arg1) << end();
 44   const int32_t* arg2 = effective_address(modrm);
 45   BINARY_ARITHMETIC_OP(+, Reg[arg1].i, *arg2);
 46   break;
 47 }
 48 
 49 //:: subtract
 50 
 51 :(scenario subtract_r32_from_mem_at_r32)
 52 % Reg[0].i = 0x60;
 53 % Mem.at(0x60) = 10;
 54 % Reg[3].i = 1;
 55 # op  ModRM   SIB   displacement  immediate
 56   29  18                                      # subtract EBX (reg 3) from *EAX (reg 0)
 57 +run: subtract reg 3 from effective address
 58 +run: effective address is mem at address 0x60 (reg 0)
 59 +run: storing 0x00000009
 60 
 61 //:
 62 
 63 :(scenario subtract_mem_at_r32_from_r32)
 64 % Reg[0].i = 0x60;
 65 % Mem.at(0x60) = 1;
 66 % Reg[3].i = 10;
 67 # op  ModRM   SIB   displacement  immediate
 68   2b  18                                      # subtract *EAX (reg 0) from EBX (reg 3)
 69 +run: subtract effective address from reg 3
 70 +run: effective address is mem at address 0x60 (reg 0)
 71 +run: storing 0x00000009
 72 
 73 :(before "End Single-Byte Opcodes")
 74 case 0x2b: {  // subtract r/m32 from r32
 75   uint8_t modrm = next();
 76   uint8_t arg1 = (modrm>>3)&0x7;
 77   trace(2, "run") << "subtract effective address from reg " << NUM(arg1) << end();
 78   const int32_t* arg2 = effective_address(modrm);
 79   BINARY_ARITHMETIC_OP(-, Reg[arg1].i, *arg2);
 80   break;
 81 }
 82 
 83 //:: and
 84 
 85 :(scenario and_r32_with_mem_at_r32)
 86 % Reg[0].i = 0x60;
 87 % Mem.at(0x60) = 0x0d;
 88 % Mem.at(0x61) = 0x0c;
 89 % Mem.at(0x62) = 0x0b;
 90 % Mem.at(0x63) = 0x0a;
 91 % Reg[3].i = 0xff;
 92 # op  ModRM   SIB   displacement  immediate
 93   21  18                                      # and EBX (reg 3) with *EAX (reg 0)
 94 +run: and reg 3 with effective address
 95 +run: effective address is mem at address 0x60 (reg 0)
 96 +run: storing 0x0000000d
 97 
 98 //:
 99 
100 :(scenario and_mem_at_r32_with_r32)
101 % Reg[0].i = 0x60;
102 % Mem.at(0x60) = 0xff;
103 % Reg[3].i = 0x0a0b0c0d;
104 # op  ModRM   SIB   displacement  immediate
105   23  18                                      # and *EAX (reg 0) with EBX (reg 3)
106 +run: and effective address with reg 3
107 +run: effective address is mem at address 0x60 (reg 0)
108 +run: storing 0x0000000d
109 
110 :(before "End Single-Byte Opcodes")
111 case 0x23: {  // and r/m32 with r32
112   uint8_t modrm = next();
113   uint8_t arg1 = (modrm>>3)&0x7;
114   trace(2, "run") << "and effective address with reg " << NUM(arg1) << end();
115   const int32_t* arg2 = effective_address(modrm);
116   BINARY_BITWISE_OP(&, Reg[arg1].u, *arg2);
117   break;
118 }
119 
120 //:: or
121 
122 :(scenario or_r32_with_mem_at_r32)
123 % Reg[0].i = 0x60;
124 % Mem.at(0x60) = 0x0d;
125 % Mem.at(0x61) = 0x0c;
126 % Mem.at(0x62) = 0x0b;
127 % Mem.at(0x63) = 0x0a;
128 % Reg[3].i = 0xa0b0c0d0;
129 # op  ModRM   SIB   displacement  immediate
130   09  18                                      # or EBX (reg 3) with *EAX (reg 0)
131 +run: or reg 3 with effective address
132 +run: effective address is mem at address 0x60 (reg 0)
133 +run: storing 0xaabbccdd
134 
135 //:
136 
137 :(scenario or_mem_at_r32_with_r32)
138 % Reg[0].i = 0x60;
139 % Mem.at(0x60) = 0x0d;
140 % Mem.at(0x61) = 0x0c;
141 % Mem.at(0x62) = 0x0b;
142 % Mem.at(0x63) = 0x0a;
143 % Reg[3].i = 0xa0b0c0d0;
144 # op  ModRM   SIB   displacement  immediate
145   0b  18                                      # or *EAX (reg 0) with EBX (reg 3)
146 +run: or effective address with reg 3
147 +run: effective address is mem at address 0x60 (reg 0)
148 +run: storing 0xaabbccdd
149 
150 :(before "End Single-Byte Opcodes")
151 case 0x0b: {  // or r/m32 with r32
152   uint8_t modrm = next();
153   uint8_t arg1 = (modrm>>3)&0x7;
154   trace(2, "run") << "or effective address with reg " << NUM(arg1) << end();
155   const int32_t* arg2 = effective_address(modrm);
156   BINARY_BITWISE_OP(|, Reg[arg1].u, *arg2);
157   break;
158 }
159 
160 //:: xor
161 
162 :(scenario xor_r32_with_mem_at_r32)
163 % Reg[0].i = 0x60;
164 % Mem.at(0x60) = 0x0d;
165 % Mem.at(0x61) = 0x0c;
166 % Mem.at(0x62) = 0xbb;
167 % Mem.at(0x63) = 0xaa;
168 % Reg[3].i = 0xa0b0c0d0;
169 # op  ModRM   SIB   displacement  immediate
170   31  18                                      # xor EBX (reg 3) with *EAX (reg 0)
171 +run: xor reg 3 with effective address
172 +run: effective address is mem at address 0x60 (reg 0)
173 +run: storing 0x0a0bccdd
174 
175 //:
176 
177 :(scenario xor_mem_at_r32_with_r32)
178 % Reg[0].i = 0x60;
179 % Mem.at(0x60) = 0x0d;
180 % Mem.at(0x61) = 0x0c;
181 % Mem.at(0x62) = 0x0b;
182 % Mem.at(0x63) = 0x0a;
183 % Reg[3].i = 0xa0b0c0d0;
184 # op  ModRM   SIB   displacement  immediate
185   33  18                                      # xor *EAX (reg 0) with EBX (reg 3)
186 +run: xor effective address with reg 3
187 +run: effective address is mem at address 0x60 (reg 0)
188 +run: storing 0xaabbccdd
189 
190 :(before "End Single-Byte Opcodes")
191 case 0x33: {  // xor r/m32 with r32
192   uint8_t modrm = next();
193   uint8_t arg1 = (modrm>>3)&0x7;
194   trace(2, "run") << "xor effective address with reg " << NUM(arg1) << end();
195   const int32_t* arg2 = effective_address(modrm);
196   BINARY_BITWISE_OP(|, Reg[arg1].u, *arg2);
197   break;
198 }
199 
200 //:: not
201 
202 :(scenario not_r32_with_mem_at_r32)
203 % Reg[3].i = 0x60;
204 # word at 0x60 is 0x0f0f00ff
205 % Mem.at(0x60) = 0xff;
206 % Mem.at(0x61) = 0x00;
207 % Mem.at(0x62) = 0x0f;
208 % Mem.at(0x63) = 0x0f;
209 # op  ModRM   SIB   displacement  immediate
210   f7  03                                      # negate *EBX (reg 3)
211 +run: 'not' of effective address
212 +run: effective address is mem at address 0x60 (reg 3)
213 +run: storing 0xf0f0ff00