From c504ca566124d1f097e7fe8a2f9f67c1c59e9ccf Mon Sep 17 00:00:00 2001 From: Kartik Agaram Date: Tue, 14 Jan 2020 01:48:06 -0800 Subject: 5893 --- html/021byte_addressing.cc.html | 66 ++++++++++++++++++++--------------------- 1 file changed, 33 insertions(+), 33 deletions(-) (limited to 'html/021byte_addressing.cc.html') diff --git a/html/021byte_addressing.cc.html b/html/021byte_addressing.cc.html index c8e11d91..7ba3f488 100644 --- a/html/021byte_addressing.cc.html +++ b/html/021byte_addressing.cc.html @@ -86,24 +86,24 @@ if ('onhashchange' in window) { 27 return reg_8bit(rm); 28 } 29 // the rest is as usual - 30 return mem_addr_u8(effective_address_number(modrm)); + 30 return mem_addr_u8(effective_address_number(modrm)); 31 } 32 33 uint8_t* reg_8bit(uint8_t rm) { - 34 uint8_t* result = reinterpret_cast<uint8_t*>(&Reg[rm & 0x3].i); // _L register + 34 uint8_t* result = reinterpret_cast<uint8_t*>(&Reg[rm & 0x3].i); // _L register 35 if (rm & 0x4) 36 ++result; // _H register; assumes host is little-endian 37 return result; 38 } 39 40 :(before "End Initialize Op Names") - 41 put_new(Name, "88", "copy r8 to r8/m8-at-r32"); + 41 put_new(Name, "88", "copy r8 to r8/m8-at-r32"); 42 43 :(code) 44 void test_copy_r8_to_mem_at_r32() { - 45 Reg[EBX].i = 0x224488ab; - 46 Reg[EAX].i = 0x2000; - 47 run( + 45 Reg[EBX].i = 0x224488ab; + 46 Reg[EAX].i = 0x2000; + 47 run( 48 "== code 0x1\n" 49 // op ModR/M SIB displacement immediate 50 " 88 18 \n" // copy BL to the byte at *EAX @@ -113,35 +113,35 @@ if ('onhashchange' in window) { 54 ); 55 CHECK_TRACE_CONTENTS( 56 "run: copy BL to r8/m8-at-r32\n" - 57 "run: effective address is 0x00002000 (EAX)\n" + 57 "run: effective address is 0x00002000 (EAX)\n" 58 "run: storing 0xab\n" 59 ); - 60 CHECK_EQ(0xaabbccab, read_mem_u32(0x2000)); + 60 CHECK_EQ(0xaabbccab, read_mem_u32(0x2000)); 61 } 62 63 :(before "End Single-Byte Opcodes") 64 case 0x88: { // copy r8 to r/m8 - 65 const uint8_t modrm = next(); + 65 const uint8_t modrm = next(); 66 const uint8_t rsrc = (modrm>>3)&0x7; 67 trace(Callstack_depth+1, "run") << "copy " << rname_8bit(rsrc) << " to r8/m8-at-r32" << end(); 68 // use unsigned to zero-extend 8-bit value to 32 bits 69 uint8_t* dest = reinterpret_cast<uint8_t*>(effective_byte_address(modrm)); 70 const uint8_t* src = reg_8bit(rsrc); 71 *dest = *src; - 72 trace(Callstack_depth+1, "run") << "storing 0x" << HEXBYTE << NUM(*dest) << end(); + 72 trace(Callstack_depth+1, "run") << "storing 0x" << HEXBYTE << NUM(*dest) << end(); 73 break; 74 } 75 76 //: 77 78 :(before "End Initialize Op Names") - 79 put_new(Name, "8a", "copy r8/m8-at-r32 to r8"); + 79 put_new(Name, "8a", "copy r8/m8-at-r32 to r8"); 80 81 :(code) 82 void test_copy_mem_at_r32_to_r8() { - 83 Reg[EBX].i = 0xaabbcc0f; // one nibble each of lowest byte set to all 0s and all 1s, to maximize value of this test - 84 Reg[EAX].i = 0x2000; - 85 run( + 83 Reg[EBX].i = 0xaabbcc0f; // one nibble each of lowest byte set to all 0s and all 1s, to maximize value of this test + 84 Reg[EAX].i = 0x2000; + 85 run( 86 "== code 0x1\n" 87 // op ModR/M SIB displacement immediate 88 " 8a 18 \n" // copy just the byte at *EAX to BL @@ -151,33 +151,33 @@ if ('onhashchange' in window) { 92 ); 93 CHECK_TRACE_CONTENTS( 94 "run: copy r8/m8-at-r32 to BL\n" - 95 "run: effective address is 0x00002000 (EAX)\n" + 95 "run: effective address is 0x00002000 (EAX)\n" 96 "run: storing 0xab\n" 97 // remaining bytes of EBX are *not* cleared - 98 "run: EBX now contains 0xaabbccab\n" + 98 "run: EBX now contains 0xaabbccab\n" 99 ); 100 } 101 102 :(before "End Single-Byte Opcodes") 103 case 0x8a: { // copy r/m8 to r8 -104 const uint8_t modrm = next(); +104 const uint8_t modrm = next(); 105 const uint8_t rdest = (modrm>>3)&0x7; 106 trace(Callstack_depth+1, "run") << "copy r8/m8-at-r32 to " << rname_8bit(rdest) << end(); 107 // use unsigned to zero-extend 8-bit value to 32 bits 108 const uint8_t* src = reinterpret_cast<uint8_t*>(effective_byte_address(modrm)); 109 uint8_t* dest = reg_8bit(rdest); -110 trace(Callstack_depth+1, "run") << "storing 0x" << HEXBYTE << NUM(*src) << end(); +110 trace(Callstack_depth+1, "run") << "storing 0x" << HEXBYTE << NUM(*src) << end(); 111 *dest = *src; 112 const uint8_t rdest_32bit = rdest & 0x3; -113 trace(Callstack_depth+1, "run") << rname(rdest_32bit) << " now contains 0x" << HEXWORD << Reg[rdest_32bit].u << end(); +113 trace(Callstack_depth+1, "run") << rname(rdest_32bit) << " now contains 0x" << HEXWORD << Reg[rdest_32bit].u << end(); 114 break; 115 } 116 117 :(code) 118 void test_cannot_copy_byte_to_ESP_EBP_ESI_EDI() { -119 Reg[ESI].u = 0xaabbccdd; -120 Reg[EBX].u = 0x11223344; -121 run( +119 Reg[ESI].u = 0xaabbccdd; +120 Reg[EBX].u = 0x11223344; +121 run( 122 "== code 0x1\n" 123 // op ModR/M SIB displacement immediate 124 " 8a f3 \n" // copy just the byte at *EBX to 8-bit register '6' @@ -189,18 +189,18 @@ if ('onhashchange' in window) { 130 "run: storing 0x44\n" 131 ); 132 // ensure ESI is unchanged -133 CHECK_EQ(Reg[ESI].u, 0xaabbccdd); +133 CHECK_EQ(Reg[ESI].u, 0xaabbccdd); 134 } 135 136 //: 137 138 :(before "End Initialize Op Names") -139 put_new(Name, "c6", "copy imm8 to r8/m8-at-r32 (mov)"); +139 put_new(Name, "c6", "copy imm8 to r8/m8-at-r32 (mov)"); 140 141 :(code) 142 void test_copy_imm8_to_mem_at_r32() { -143 Reg[EAX].i = 0x2000; -144 run( +143 Reg[EAX].i = 0x2000; +144 run( 145 "== code 0x1\n" 146 // op ModR/M SIB displacement immediate 147 " c6 00 dd \n" // copy to the byte at *EAX @@ -210,27 +210,27 @@ if ('onhashchange' in window) { 151 ); 152 CHECK_TRACE_CONTENTS( 153 "run: copy imm8 to r8/m8-at-r32\n" -154 "run: effective address is 0x00002000 (EAX)\n" +154 "run: effective address is 0x00002000 (EAX)\n" 155 "run: storing 0xdd\n" 156 ); -157 CHECK_EQ(0xaabbccdd, read_mem_u32(0x2000)); +157 CHECK_EQ(0xaabbccdd, read_mem_u32(0x2000)); 158 } 159 160 :(before "End Single-Byte Opcodes") 161 case 0xc6: { // copy imm8 to r/m8 -162 const uint8_t modrm = next(); -163 const uint8_t src = next(); +162 const uint8_t modrm = next(); +163 const uint8_t src = next(); 164 trace(Callstack_depth+1, "run") << "copy imm8 to r8/m8-at-r32" << end(); -165 trace(Callstack_depth+1, "run") << "imm8 is 0x" << HEXWORD << NUM(src) << end(); +165 trace(Callstack_depth+1, "run") << "imm8 is 0x" << HEXWORD << NUM(src) << end(); 166 const uint8_t subop = (modrm>>3)&0x7; // middle 3 'reg opcode' bits 167 if (subop != 0) { -168 cerr << "unrecognized subop for opcode c6: " << NUM(subop) << " (only 0/copy currently implemented)\n"; +168 cerr << "unrecognized subop for opcode c6: " << NUM(subop) << " (only 0/copy currently implemented)\n"; 169 exit(1); 170 } 171 // use unsigned to zero-extend 8-bit value to 32 bits 172 uint8_t* dest = reinterpret_cast<uint8_t*>(effective_byte_address(modrm)); 173 *dest = src; -174 trace(Callstack_depth+1, "run") << "storing 0x" << HEXBYTE << NUM(*dest) << end(); +174 trace(Callstack_depth+1, "run") << "storing 0x" << HEXBYTE << NUM(*dest) << end(); 175 break; 176 } -- cgit 1.4.1-2-gfad0