From 9e45873ff4a5af5fc2bb2fcab90accef171900f1 Mon Sep 17 00:00:00 2001 From: "Kartik K. Agaram" Date: Wed, 18 Oct 2017 00:57:46 -0700 Subject: [PATCH] 4079 subx: 'pop' --- html/subx/011direct_addressing.cc.html | 26 +++++++++++ html/subx/012indirect_addressing.cc.html | 47 +++++++++++++++----- html/subx/013immediate_addressing.cc.html | 54 ++++++++++++++++------- subx/011direct_addressing.cc | 26 +++++++++++ subx/012indirect_addressing.cc | 41 ++++++++++++++--- subx/013immediate_addressing.cc | 22 +++++++++ 6 files changed, 183 insertions(+), 33 deletions(-) diff --git a/html/subx/011direct_addressing.cc.html b/html/subx/011direct_addressing.cc.html index 1738b2a2..dba0b3cf 100644 --- a/html/subx/011direct_addressing.cc.html +++ b/html/subx/011direct_addressing.cc.html @@ -279,6 +279,32 @@ if ('onhashchange' in window) { 214 trace(2, "run") << "storing 0x" << HEXWORD << *arg1 << end(); 215 break; 216 } +217 +218 //:: push +219 +220 :(scenario push_r32) +221 % Reg[ESP].u = 0x64; +222 % Reg[EBX].i = 10; +223 # op ModRM SIB displacement immediate +224 50 03 # push EBX (reg 3) to stack +225 +run: push reg 3 +226 +run: pushing value 0x0000000a +227 +run: ESP is now 0x00000060 +228 +run: contents at ESP: 0x0000000a +229 +230 :(before "End Single-Byte Opcodes") +231 case 0x50: { +232 uint8_t modrm = next(); +233 uint8_t reg = modrm & 0x7; +234 trace(2, "run") << "push reg " << NUM(reg) << end(); +235 const int32_t val = Reg[reg].u; +236 trace(2, "run") << "pushing value 0x" << HEXWORD << val << end(); +237 Reg[ESP].u -= 4; +238 *reinterpret_cast<uint32_t*>(&Mem.at(Reg[ESP].u)) = val; +239 trace(2, "run") << "ESP is now 0x" << HEXWORD << Reg[ESP].u << end(); +240 trace(2, "run") << "contents at ESP: 0x" << HEXWORD << *reinterpret_cast<uint32_t*>(&Mem.at(Reg[ESP].u)) << end(); +241 break; +242 } diff --git a/html/subx/012indirect_addressing.cc.html b/html/subx/012indirect_addressing.cc.html index d04c442e..2643bcaf 100644 --- a/html/subx/012indirect_addressing.cc.html +++ b/html/subx/012indirect_addressing.cc.html @@ -392,16 +392,43 @@ if ('onhashchange' in window) { 327 uint8_t modrm = next(); 328 uint8_t subop = (modrm>>3)&0x7; // middle 3 'reg opcode' bits 329 switch (subop) { -330 case 4: -331 ¦ trace(2, "run") << "jump to effective address" << end(); -332 ¦ int32_t* arg2 = effective_address(modrm); -333 ¦ EIP = *arg2; -334 ¦ trace(2, "run") << "jumping to 0x" << HEXWORD << EIP << end(); -335 ¦ break; -336 // End Op ff Subops -337 } -338 break; -339 } +330 ¦ case 4: { +331 ¦ ¦ trace(2, "run") << "jump to effective address" << end(); +332 ¦ ¦ int32_t* arg2 = effective_address(modrm); +333 ¦ ¦ EIP = *arg2; +334 ¦ ¦ trace(2, "run") << "jumping to 0x" << HEXWORD << EIP << end(); +335 ¦ ¦ break; +336 ¦ } +337 ¦ // End Op ff Subops +338 } +339 break; +340 } +341 +342 //:: push +343 +344 :(scenario push_mem_at_r32) +345 % Reg[0].i = 0x60; +346 % SET_WORD_IN_MEM(0x60, 0x000000af); +347 % Reg[ESP].u = 0x14; +348 # op ModRM SIB displacement immediate +349 ff 30 # push *EAX (reg 0) to stack +350 +run: push effective address +351 +run: effective address is mem at address 0x60 (reg 0) +352 +run: ESP is now 0x00000010 +353 +run: contents at ESP: 0x000000af +354 +355 :(before "End Op ff Subops") +356 case 6: { +357 trace(2, "run") << "push effective address" << end(); +358 const int32_t* val = effective_address(modrm); +359 trace(2, "run") << "pushing value 0x" << HEXWORD << *val << end(); +360 Reg[ESP].u -= 4; +361 *reinterpret_cast<uint32_t*>(&Mem.at(Reg[ESP].u)) = *val; +362 trace(2, "run") << "ESP is now 0x" << HEXWORD << Reg[ESP].u << end(); +363 trace(2, "run") << "contents at ESP: 0x" << HEXWORD << *reinterpret_cast<uint32_t*>(&Mem.at(Reg[ESP].u)) << end(); +364 break; +365 } +366 diff --git a/html/subx/013immediate_addressing.cc.html b/html/subx/013immediate_addressing.cc.html index bde49732..adaff3e0 100644 --- a/html/subx/013immediate_addressing.cc.html +++ b/html/subx/013immediate_addressing.cc.html @@ -414,22 +414,44 @@ if ('onhashchange' in window) { 350 } 351 352 //: -353 :(scenario copy_imm32_to_mem_at_r32) -354 % Reg[3].i = 0x60; -355 # op ModRM SIB displacement immediate -356 c7 03 0a 0b 0c 0d # copy 0x0d0c0b0a to *EBX (reg 3) -357 +run: copy imm32 0x0d0c0b0a to effective address -358 +run: effective address is mem at address 0x60 (reg 3) -359 -360 :(before "End Single-Byte Opcodes") -361 case 0xc7: { // copy imm32 to r32 -362 uint8_t modrm = next(); -363 int32_t arg2 = imm32(); -364 trace(2, "run") << "copy imm32 0x" << HEXWORD << arg2 << " to effective address" << end(); -365 int32_t* arg1 = effective_address(modrm); -366 *arg1 = arg2; -367 break; -368 } +353 +354 :(scenario copy_imm32_to_mem_at_r32) +355 % Reg[3].i = 0x60; +356 # op ModRM SIB displacement immediate +357 c7 03 0a 0b 0c 0d # copy 0x0d0c0b0a to *EBX (reg 3) +358 +run: copy imm32 0x0d0c0b0a to effective address +359 +run: effective address is mem at address 0x60 (reg 3) +360 +361 :(before "End Single-Byte Opcodes") +362 case 0xc7: { // copy imm32 to r32 +363 uint8_t modrm = next(); +364 int32_t arg2 = imm32(); +365 trace(2, "run") << "copy imm32 0x" << HEXWORD << arg2 << " to effective address" << end(); +366 int32_t* arg1 = effective_address(modrm); +367 *arg1 = arg2; +368 break; +369 } +370 +371 //:: push +372 +373 :(scenario push_imm32) +374 % Reg[ESP].u = 0x14; +375 # op ModRM SIB displacement immediate +376 68 af 00 00 00 # push *EAX (reg 0) to stack +377 +run: push imm32 0x000000af +378 +run: ESP is now 0x00000010 +379 +run: contents at ESP: 0x000000af +380 +381 :(before "End Single-Byte Opcodes") +382 case 0x68: { +383 int32_t val = imm32(); +384 trace(2, "run") << "push imm32 0x" << HEXWORD << val << end(); +385 Reg[ESP].u -= 4; +386 *reinterpret_cast<uint32_t*>(&Mem.at(Reg[ESP].u)) = val; +387 trace(2, "run") << "ESP is now 0x" << HEXWORD << Reg[ESP].u << end(); +388 trace(2, "run") << "contents at ESP: 0x" << HEXWORD << *reinterpret_cast<uint32_t*>(&Mem.at(Reg[ESP].u)) << end(); +389 break; +390 } diff --git a/subx/011direct_addressing.cc b/subx/011direct_addressing.cc index f474ac99..2defcfec 100644 --- a/subx/011direct_addressing.cc +++ b/subx/011direct_addressing.cc @@ -214,3 +214,29 @@ case 0x89: { // copy r32 to r/m32 trace(2, "run") << "storing 0x" << HEXWORD << *arg1 << end(); break; } + +//:: push + +:(scenario push_r32) +% Reg[ESP].u = 0x64; +% Reg[EBX].i = 10; +# op ModRM SIB displacement immediate + 50 03 # push EBX (reg 3) to stack ++run: push reg 3 ++run: pushing value 0x0000000a ++run: ESP is now 0x00000060 ++run: contents at ESP: 0x0000000a + +:(before "End Single-Byte Opcodes") +case 0x50: { + uint8_t modrm = next(); + uint8_t reg = modrm & 0x7; + trace(2, "run") << "push reg " << NUM(reg) << end(); + const int32_t val = Reg[reg].u; + trace(2, "run") << "pushing value 0x" << HEXWORD << val << end(); + Reg[ESP].u -= 4; + *reinterpret_cast(&Mem.at(Reg[ESP].u)) = val; + trace(2, "run") << "ESP is now 0x" << HEXWORD << Reg[ESP].u << end(); + trace(2, "run") << "contents at ESP: 0x" << HEXWORD << *reinterpret_cast(&Mem.at(Reg[ESP].u)) << end(); + break; +} diff --git a/subx/012indirect_addressing.cc b/subx/012indirect_addressing.cc index 1bf5e378..b4821856 100644 --- a/subx/012indirect_addressing.cc +++ b/subx/012indirect_addressing.cc @@ -327,13 +327,40 @@ case 0xff: { // jump to r/m32 uint8_t modrm = next(); uint8_t subop = (modrm>>3)&0x7; // middle 3 'reg opcode' bits switch (subop) { - case 4: - trace(2, "run") << "jump to effective address" << end(); - int32_t* arg2 = effective_address(modrm); - EIP = *arg2; - trace(2, "run") << "jumping to 0x" << HEXWORD << EIP << end(); - break; - // End Op ff Subops + case 4: { + trace(2, "run") << "jump to effective address" << end(); + int32_t* arg2 = effective_address(modrm); + EIP = *arg2; + trace(2, "run") << "jumping to 0x" << HEXWORD << EIP << end(); + break; + } + // End Op ff Subops } break; } + +//:: push + +:(scenario push_mem_at_r32) +% Reg[0].i = 0x60; +% SET_WORD_IN_MEM(0x60, 0x000000af); +% Reg[ESP].u = 0x14; +# op ModRM SIB displacement immediate + ff 30 # push *EAX (reg 0) to stack ++run: push effective address ++run: effective address is mem at address 0x60 (reg 0) ++run: ESP is now 0x00000010 ++run: contents at ESP: 0x000000af + +:(before "End Op ff Subops") +case 6: { + trace(2, "run") << "push effective address" << end(); + const int32_t* val = effective_address(modrm); + trace(2, "run") << "pushing value 0x" << HEXWORD << *val << end(); + Reg[ESP].u -= 4; + *reinterpret_cast(&Mem.at(Reg[ESP].u)) = *val; + trace(2, "run") << "ESP is now 0x" << HEXWORD << Reg[ESP].u << end(); + trace(2, "run") << "contents at ESP: 0x" << HEXWORD << *reinterpret_cast(&Mem.at(Reg[ESP].u)) << end(); + break; +} + diff --git a/subx/013immediate_addressing.cc b/subx/013immediate_addressing.cc index dd1ce4c0..2e4b459a 100644 --- a/subx/013immediate_addressing.cc +++ b/subx/013immediate_addressing.cc @@ -350,6 +350,7 @@ case 0xb8: { // copy imm32 to r32 } //: + :(scenario copy_imm32_to_mem_at_r32) % Reg[3].i = 0x60; # op ModRM SIB displacement immediate @@ -366,3 +367,24 @@ case 0xc7: { // copy imm32 to r32 *arg1 = arg2; break; } + +//:: push + +:(scenario push_imm32) +% Reg[ESP].u = 0x14; +# op ModRM SIB displacement immediate + 68 af 00 00 00 # push *EAX (reg 0) to stack ++run: push imm32 0x000000af ++run: ESP is now 0x00000010 ++run: contents at ESP: 0x000000af + +:(before "End Single-Byte Opcodes") +case 0x68: { + int32_t val = imm32(); + trace(2, "run") << "push imm32 0x" << HEXWORD << val << end(); + Reg[ESP].u -= 4; + *reinterpret_cast(&Mem.at(Reg[ESP].u)) = val; + trace(2, "run") << "ESP is now 0x" << HEXWORD << Reg[ESP].u << end(); + trace(2, "run") << "contents at ESP: 0x" << HEXWORD << *reinterpret_cast(&Mem.at(Reg[ESP].u)) << end(); + break; +}