From 9c1056f531217f3c1c12b3b3a648ca1cffe4beab Mon Sep 17 00:00:00 2001 From: Kartik Agaram Date: Fri, 29 Mar 2019 00:47:30 -0700 Subject: 5033 --- html/subx/018jump_disp32.cc.html | 645 ++++++++++++++++++++++----------------- 1 file changed, 363 insertions(+), 282 deletions(-) (limited to 'html/subx/018jump_disp32.cc.html') diff --git a/html/subx/018jump_disp32.cc.html b/html/subx/018jump_disp32.cc.html index 140450b0..c23d4b8e 100644 --- a/html/subx/018jump_disp32.cc.html +++ b/html/subx/018jump_disp32.cc.html @@ -14,9 +14,6 @@ pre { white-space: pre-wrap; font-family: monospace; color: #000000; background- body { font-size:12pt; font-family: monospace; color: #000000; background-color: #c6c6c6; } a { color:inherit; } * { font-size:12pt; font-size: 1em; } -.traceAbsent { color: #c00000; } -.traceContains { color: #005f00; } -.PreProc { color: #c000c0; } .LineNr { } .Constant { color: #008787; } .Delimiter { color: #c000c0; } @@ -65,288 +62,372 @@ if ('onhashchange' in window) { 3 //:: jump 4 5 :(before "End Initialize Op Names") - 6 put_new(Name, "e9", "jump disp32 bytes away (jmp)"); + 6 put_new(Name, "e9", "jump disp32 bytes away (jmp)"); 7 - 8 :(scenario jump_disp32) - 9 == 0x1 - 10 # op ModR/M SIB displacement immediate - 11 e9 05 00 00 00 # skip 1 instruction - 12 05 00 00 00 01 - 13 05 00 00 00 02 - 14 +run: 0x00000001 opcode: e9 - 15 +run: jump 5 - 16 +run: 0x0000000b opcode: 05 - 17 -run: 0x00000006 opcode: 05 - 18 - 19 :(before "End Single-Byte Opcodes") - 20 case 0xe9: { // jump disp32 - 21 const int32_t offset = next32(); - 22 trace(Callstack_depth+1, "run") << "jump " << offset << end(); - 23 EIP += offset; - 24 break; - 25 } - 26 - 27 //:: jump if equal/zero - 28 - 29 :(before "End Initialize Op Names") - 30 put_new(Name_0f, "84", "jump disp32 bytes away if equal, if ZF is set (jcc/jz/je)"); - 31 - 32 :(scenario je_disp32_success) - 33 % ZF = true; - 34 == 0x1 - 35 # op ModR/M SIB displacement immediate - 36 0f 84 05 00 00 00 # skip 1 instruction - 37 05 00 00 00 01 - 38 05 00 00 00 02 - 39 +run: 0x00000001 opcode: 0f - 40 +run: jump 5 - 41 +run: 0x0000000c opcode: 05 - 42 -run: 0x00000007 opcode: 05 - 43 - 44 :(before "End Two-Byte Opcodes Starting With 0f") - 45 case 0x84: { // jump disp32 if ZF - 46 const int32_t offset = next32(); - 47 if (ZF) { - 48 trace(Callstack_depth+1, "run") << "jump " << NUM(offset) << end(); - 49 EIP += offset; - 50 } - 51 break; - 52 } - 53 - 54 :(scenario je_disp32_fail) - 55 % ZF = false; - 56 == 0x1 - 57 # op ModR/M SIB displacement immediate - 58 0f 84 05 00 00 00 # skip 1 instruction - 59 05 00 00 00 01 - 60 05 00 00 00 02 - 61 +run: 0x00000001 opcode: 0f - 62 +run: 0x00000007 opcode: 05 - 63 +run: 0x0000000c opcode: 05 - 64 -run: jump 5 + 8 :(code) + 9 void test_jump_disp32() { + 10 run( + 11 "== 0x1\n" // code segment + 12 // op ModR/M SIB displacement immediate + 13 " e9 05 00 00 00 \n" // skip 1 instruction + 14 " 05 00 00 00 01 \n" + 15 " 05 00 00 00 02 \n" + 16 ); + 17 CHECK_TRACE_CONTENTS( + 18 "run: 0x00000001 opcode: e9\n" + 19 "run: jump 5\n" + 20 "run: 0x0000000b opcode: 05\n" + 21 ); + 22 CHECK_TRACE_DOESNT_CONTAIN("run: 0x00000006 opcode: 05"); + 23 } + 24 + 25 :(before "End Single-Byte Opcodes") + 26 case 0xe9: { // jump disp32 + 27 const int32_t offset = next32(); + 28 trace(Callstack_depth+1, "run") << "jump " << offset << end(); + 29 EIP += offset; + 30 break; + 31 } + 32 + 33 //:: jump if equal/zero + 34 + 35 :(before "End Initialize Op Names") + 36 put_new(Name_0f, "84", "jump disp32 bytes away if equal, if ZF is set (jcc/jz/je)"); + 37 + 38 :(code) + 39 void test_je_disp32_success() { + 40 ZF = true; + 41 run( + 42 "== 0x1\n" // code segment + 43 // op ModR/M SIB displacement immediate + 44 " 0f 84 05 00 00 00 \n" // skip 1 instruction + 45 " 05 00 00 00 01 \n" + 46 " 05 00 00 00 02 \n" + 47 ); + 48 CHECK_TRACE_CONTENTS( + 49 "run: 0x00000001 opcode: 0f\n" + 50 "run: jump 5\n" + 51 "run: 0x0000000c opcode: 05\n" + 52 ); + 53 CHECK_TRACE_DOESNT_CONTAIN("run: 0x00000007 opcode: 05"); + 54 } + 55 + 56 :(before "End Two-Byte Opcodes Starting With 0f") + 57 case 0x84: { // jump disp32 if ZF + 58 const int32_t offset = next32(); + 59 if (ZF) { + 60 trace(Callstack_depth+1, "run") << "jump " << NUM(offset) << end(); + 61 EIP += offset; + 62 } + 63 break; + 64 } 65 - 66 //:: jump if not equal/not zero - 67 - 68 :(before "End Initialize Op Names") - 69 put_new(Name_0f, "85", "jump disp32 bytes away if not equal, if ZF is not set (jcc/jnz/jne)"); - 70 - 71 :(scenario jne_disp32_success) - 72 % ZF = false; - 73 == 0x1 - 74 # op ModR/M SIB displacement immediate - 75 0f 85 05 00 00 00 # skip 1 instruction - 76 05 00 00 00 01 - 77 05 00 00 00 02 - 78 +run: 0x00000001 opcode: 0f - 79 +run: jump 5 - 80 +run: 0x0000000c opcode: 05 - 81 -run: 0x00000007 opcode: 05 - 82 - 83 :(before "End Two-Byte Opcodes Starting With 0f") - 84 case 0x85: { // jump disp32 unless ZF - 85 const int32_t offset = next32(); - 86 if (!ZF) { - 87 trace(Callstack_depth+1, "run") << "jump " << NUM(offset) << end(); - 88 EIP += offset; - 89 } - 90 break; - 91 } - 92 - 93 :(scenario jne_disp32_fail) - 94 % ZF = true; - 95 == 0x1 - 96 # op ModR/M SIB displacement immediate - 97 0f 85 05 00 00 00 # skip 1 instruction - 98 05 00 00 00 01 - 99 05 00 00 00 02 -100 +run: 0x00000001 opcode: 0f -101 +run: 0x00000007 opcode: 05 -102 +run: 0x0000000c opcode: 05 -103 -run: jump 5 -104 -105 //:: jump if greater + 66 :(code) + 67 void test_je_disp32_fail() { + 68 ZF = false; + 69 run( + 70 "== 0x1\n" // code segment + 71 // op ModR/M SIB displacement immediate + 72 " 0f 84 05 00 00 00 \n" // skip 1 instruction + 73 " 05 00 00 00 01 \n" + 74 " 05 00 00 00 02 \n" + 75 ); + 76 CHECK_TRACE_CONTENTS( + 77 "run: 0x00000001 opcode: 0f\n" + 78 "run: 0x00000007 opcode: 05\n" + 79 "run: 0x0000000c opcode: 05\n" + 80 ); + 81 CHECK_TRACE_DOESNT_CONTAIN("run: jump 5"); + 82 } + 83 + 84 //:: jump if not equal/not zero + 85 + 86 :(before "End Initialize Op Names") + 87 put_new(Name_0f, "85", "jump disp32 bytes away if not equal, if ZF is not set (jcc/jnz/jne)"); + 88 + 89 :(code) + 90 void test_jne_disp32_success() { + 91 ZF = false; + 92 run( + 93 "== 0x1\n" // code segment + 94 // op ModR/M SIB displacement immediate + 95 " 0f 85 05 00 00 00 \n" // skip 1 instruction + 96 " 05 00 00 00 01 \n" + 97 " 05 00 00 00 02 \n" + 98 ); + 99 CHECK_TRACE_CONTENTS( +100 "run: 0x00000001 opcode: 0f\n" +101 "run: jump 5\n" +102 "run: 0x0000000c opcode: 05\n" +103 ); +104 CHECK_TRACE_DOESNT_CONTAIN("run: 0x00000007 opcode: 05"); +105 } 106 -107 :(before "End Initialize Op Names") -108 put_new(Name_0f, "8f", "jump disp32 bytes away if greater, if ZF is unset and SF == OF (jcc/jg/jnle)"); -109 -110 :(scenario jg_disp32_success) -111 % ZF = false; -112 % SF = false; -113 % OF = false; -114 == 0x1 -115 # op ModR/M SIB displacement immediate -116 0f 8f 05 00 00 00 # skip 1 instruction -117 05 00 00 00 01 -118 05 00 00 00 02 -119 +run: 0x00000001 opcode: 0f -120 +run: jump 5 -121 +run: 0x0000000c opcode: 05 -122 -run: 0x00000007 opcode: 05 -123 -124 :(before "End Two-Byte Opcodes Starting With 0f") -125 case 0x8f: { // jump disp32 if !SF and !ZF -126 const int32_t offset = next32(); -127 if (!ZF && SF == OF) { -128 trace(Callstack_depth+1, "run") << "jump " << NUM(offset) << end(); -129 EIP += offset; -130 } -131 break; -132 } -133 -134 :(scenario jg_disp32_fail) -135 % ZF = false; -136 % SF = true; -137 % OF = false; -138 == 0x1 -139 # op ModR/M SIB displacement immediate -140 0f 8f 05 00 00 00 # skip 1 instruction -141 05 00 00 00 01 -142 05 00 00 00 02 -143 +run: 0x00000001 opcode: 0f -144 +run: 0x00000007 opcode: 05 -145 +run: 0x0000000c opcode: 05 -146 -run: jump 5 -147 -148 //:: jump if greater or equal -149 -150 :(before "End Initialize Op Names") -151 put_new(Name_0f, "8d", "jump disp32 bytes away if greater or equal, if SF == OF (jcc/jge/jnl)"); -152 -153 :(scenario jge_disp32_success) -154 % SF = false; -155 % OF = false; -156 == 0x1 -157 # op ModR/M SIB displacement immediate -158 0f 8d 05 00 00 00 # skip 1 instruction -159 05 00 00 00 01 -160 05 00 00 00 02 -161 +run: 0x00000001 opcode: 0f -162 +run: jump 5 -163 +run: 0x0000000c opcode: 05 -164 -run: 0x00000007 opcode: 05 -165 -166 :(before "End Two-Byte Opcodes Starting With 0f") -167 case 0x8d: { // jump disp32 if !SF -168 const int32_t offset = next32(); -169 if (SF == OF) { -170 trace(Callstack_depth+1, "run") << "jump " << NUM(offset) << end(); -171 EIP += offset; -172 } -173 break; -174 } -175 -176 :(scenario jge_disp32_fail) -177 % SF = true; -178 % OF = false; -179 == 0x1 -180 # op ModR/M SIB displacement immediate -181 0f 8d 05 00 00 00 # skip 1 instruction -182 05 00 00 00 01 -183 05 00 00 00 02 -184 +run: 0x00000001 opcode: 0f -185 +run: 0x00000007 opcode: 05 -186 +run: 0x0000000c opcode: 05 -187 -run: jump 5 -188 -189 //:: jump if lesser -190 -191 :(before "End Initialize Op Names") -192 put_new(Name_0f, "8c", "jump disp32 bytes away if lesser, if SF != OF (jcc/jl/jnge)"); -193 -194 :(scenario jl_disp32_success) -195 % ZF = false; -196 % SF = true; -197 % OF = false; -198 == 0x1 -199 # op ModR/M SIB displacement immediate -200 0f 8c 05 00 00 00 # skip 1 instruction -201 05 00 00 00 01 -202 05 00 00 00 02 -203 +run: 0x00000001 opcode: 0f -204 +run: jump 5 -205 +run: 0x0000000c opcode: 05 -206 -run: 0x00000007 opcode: 05 -207 -208 :(before "End Two-Byte Opcodes Starting With 0f") -209 case 0x8c: { // jump disp32 if SF and !ZF -210 const int32_t offset = next32(); -211 if (SF != OF) { -212 trace(Callstack_depth+1, "run") << "jump " << NUM(offset) << end(); -213 EIP += offset; -214 } -215 break; -216 } -217 -218 :(scenario jl_disp32_fail) -219 % ZF = false; -220 % SF = false; -221 % OF = false; -222 == 0x1 -223 # op ModR/M SIB displacement immediate -224 0f 8c 05 00 00 00 # skip 1 instruction -225 05 00 00 00 01 -226 05 00 00 00 02 -227 +run: 0x00000001 opcode: 0f -228 +run: 0x00000007 opcode: 05 -229 +run: 0x0000000c opcode: 05 -230 -run: jump 5 -231 -232 //:: jump if lesser or equal -233 -234 :(before "End Initialize Op Names") -235 put_new(Name_0f, "8e", "jump disp32 bytes away if lesser or equal, if ZF is set or SF != OF (jcc/jle/jng)"); -236 -237 :(scenario jle_disp32_equal) -238 % ZF = true; -239 % SF = false; -240 % OF = false; -241 == 0x1 -242 # op ModR/M SIB displacement immediate -243 0f 8e 05 00 00 00 # skip 1 instruction -244 05 00 00 00 01 -245 05 00 00 00 02 -246 +run: 0x00000001 opcode: 0f -247 +run: jump 5 -248 +run: 0x0000000c opcode: 05 -249 -run: 0x00000007 opcode: 05 -250 -251 :(scenario jle_disp32_lesser) -252 % ZF = false; -253 % SF = true; -254 % OF = false; -255 == 0x1 -256 # op ModR/M SIB displacement immediate -257 0f 8e 05 00 00 00 # skip 1 instruction -258 05 00 00 00 01 -259 05 00 00 00 02 -260 +run: 0x00000001 opcode: 0f -261 +run: jump 5 -262 +run: 0x0000000c opcode: 05 -263 -run: 0x00000007 opcode: 05 -264 -265 :(before "End Two-Byte Opcodes Starting With 0f") -266 case 0x8e: { // jump disp32 if SF or ZF -267 const int32_t offset = next32(); -268 if (ZF || SF != OF) { -269 trace(Callstack_depth+1, "run") << "jump " << NUM(offset) << end(); -270 EIP += offset; -271 } -272 break; -273 } -274 -275 :(scenario jle_disp32_greater) -276 % ZF = false; -277 % SF = false; -278 % OF = false; -279 == 0x1 -280 # op ModR/M SIB displacement immediate -281 0f 8e 05 00 00 00 # skip 1 instruction -282 05 00 00 00 01 -283 05 00 00 00 02 -284 +run: 0x00000001 opcode: 0f -285 +run: 0x00000007 opcode: 05 -286 +run: 0x0000000c opcode: 05 -287 -run: jump 5 +107 :(before "End Two-Byte Opcodes Starting With 0f") +108 case 0x85: { // jump disp32 unless ZF +109 const int32_t offset = next32(); +110 if (!ZF) { +111 trace(Callstack_depth+1, "run") << "jump " << NUM(offset) << end(); +112 EIP += offset; +113 } +114 break; +115 } +116 +117 :(code) +118 void test_jne_disp32_fail() { +119 ZF = true; +120 run( +121 "== 0x1\n" // code segment +122 // op ModR/M SIB displacement immediate +123 " 0f 85 05 00 00 00 \n" // skip 1 instruction +124 " 05 00 00 00 01 \n" +125 " 05 00 00 00 02 \n" +126 ); +127 CHECK_TRACE_CONTENTS( +128 "run: 0x00000001 opcode: 0f\n" +129 "run: 0x00000007 opcode: 05\n" +130 "run: 0x0000000c opcode: 05\n" +131 ); +132 CHECK_TRACE_DOESNT_CONTAIN("run: jump 5"); +133 } +134 +135 //:: jump if greater +136 +137 :(before "End Initialize Op Names") +138 put_new(Name_0f, "8f", "jump disp32 bytes away if greater, if ZF is unset and SF == OF (jcc/jg/jnle)"); +139 +140 :(code) +141 void test_jg_disp32_success() { +142 ZF = false; +143 SF = false; +144 OF = false; +145 run( +146 "== 0x1\n" // code segment +147 // op ModR/M SIB displacement immediate +148 " 0f 8f 05 00 00 00 \n" // skip 1 instruction +149 " 05 00 00 00 01 \n" +150 " 05 00 00 00 02 \n" +151 ); +152 CHECK_TRACE_CONTENTS( +153 "run: 0x00000001 opcode: 0f\n" +154 "run: jump 5\n" +155 "run: 0x0000000c opcode: 05\n" +156 ); +157 CHECK_TRACE_DOESNT_CONTAIN("run: 0x00000007 opcode: 05"); +158 } +159 +160 :(before "End Two-Byte Opcodes Starting With 0f") +161 case 0x8f: { // jump disp32 if !SF and !ZF +162 const int32_t offset = next32(); +163 if (!ZF && SF == OF) { +164 trace(Callstack_depth+1, "run") << "jump " << NUM(offset) << end(); +165 EIP += offset; +166 } +167 break; +168 } +169 +170 :(code) +171 void test_jg_disp32_fail() { +172 ZF = false; +173 SF = true; +174 OF = false; +175 run( +176 "== 0x1\n" // code segment +177 // op ModR/M SIB displacement immediate +178 " 0f 8f 05 00 00 00 \n" // skip 1 instruction +179 " 05 00 00 00 01 \n" +180 " 05 00 00 00 02 \n" +181 ); +182 CHECK_TRACE_CONTENTS( +183 "run: 0x00000001 opcode: 0f\n" +184 "run: 0x00000007 opcode: 05\n" +185 "run: 0x0000000c opcode: 05\n" +186 ); +187 CHECK_TRACE_DOESNT_CONTAIN("run: jump 5"); +188 } +189 +190 //:: jump if greater or equal +191 +192 :(before "End Initialize Op Names") +193 put_new(Name_0f, "8d", "jump disp32 bytes away if greater or equal, if SF == OF (jcc/jge/jnl)"); +194 +195 :(code) +196 void test_jge_disp32_success() { +197 SF = false; +198 OF = false; +199 run( +200 "== 0x1\n" // code segment +201 // op ModR/M SIB displacement immediate +202 " 0f 8d 05 00 00 00 \n" // skip 1 instruction +203 " 05 00 00 00 01 \n" +204 " 05 00 00 00 02 \n" +205 ); +206 CHECK_TRACE_CONTENTS( +207 "run: 0x00000001 opcode: 0f\n" +208 "run: jump 5\n" +209 "run: 0x0000000c opcode: 05\n" +210 ); +211 CHECK_TRACE_DOESNT_CONTAIN("run: 0x00000007 opcode: 05"); +212 } +213 +214 :(before "End Two-Byte Opcodes Starting With 0f") +215 case 0x8d: { // jump disp32 if !SF +216 const int32_t offset = next32(); +217 if (SF == OF) { +218 trace(Callstack_depth+1, "run") << "jump " << NUM(offset) << end(); +219 EIP += offset; +220 } +221 break; +222 } +223 +224 :(code) +225 void test_jge_disp32_fail() { +226 SF = true; +227 OF = false; +228 run( +229 "== 0x1\n" // code segment +230 // op ModR/M SIB displacement immediate +231 " 0f 8d 05 00 00 00 \n" // skip 1 instruction +232 " 05 00 00 00 01 \n" +233 " 05 00 00 00 02 \n" +234 ); +235 CHECK_TRACE_CONTENTS( +236 "run: 0x00000001 opcode: 0f\n" +237 "run: 0x00000007 opcode: 05\n" +238 "run: 0x0000000c opcode: 05\n" +239 ); +240 CHECK_TRACE_DOESNT_CONTAIN("run: jump 5"); +241 } +242 +243 //:: jump if lesser +244 +245 :(before "End Initialize Op Names") +246 put_new(Name_0f, "8c", "jump disp32 bytes away if lesser, if SF != OF (jcc/jl/jnge)"); +247 +248 :(code) +249 void test_jl_disp32_success() { +250 ZF = false; +251 SF = true; +252 OF = false; +253 run( +254 "== 0x1\n" // code segment +255 // op ModR/M SIB displacement immediate +256 " 0f 8c 05 00 00 00 \n" // skip 1 instruction +257 " 05 00 00 00 01 \n" +258 " 05 00 00 00 02 \n" +259 ); +260 CHECK_TRACE_CONTENTS( +261 "run: 0x00000001 opcode: 0f\n" +262 "run: jump 5\n" +263 "run: 0x0000000c opcode: 05\n" +264 ); +265 CHECK_TRACE_DOESNT_CONTAIN("run: 0x00000007 opcode: 05"); +266 } +267 +268 :(before "End Two-Byte Opcodes Starting With 0f") +269 case 0x8c: { // jump disp32 if SF and !ZF +270 const int32_t offset = next32(); +271 if (SF != OF) { +272 trace(Callstack_depth+1, "run") << "jump " << NUM(offset) << end(); +273 EIP += offset; +274 } +275 break; +276 } +277 +278 :(code) +279 void test_jl_disp32_fail() { +280 ZF = false; +281 SF = false; +282 OF = false; +283 run( +284 "== 0x1\n" // code segment +285 // op ModR/M SIB displacement immediate +286 " 0f 8c 05 00 00 00 \n" // skip 1 instruction +287 " 05 00 00 00 01 \n" +288 " 05 00 00 00 02 \n" +289 ); +290 CHECK_TRACE_CONTENTS( +291 "run: 0x00000001 opcode: 0f\n" +292 "run: 0x00000007 opcode: 05\n" +293 "run: 0x0000000c opcode: 05\n" +294 ); +295 CHECK_TRACE_DOESNT_CONTAIN("run: jump 5"); +296 } +297 +298 //:: jump if lesser or equal +299 +300 :(before "End Initialize Op Names") +301 put_new(Name_0f, "8e", "jump disp32 bytes away if lesser or equal, if ZF is set or SF != OF (jcc/jle/jng)"); +302 +303 :(code) +304 void test_jle_disp32_equal() { +305 ZF = true; +306 SF = false; +307 OF = false; +308 run( +309 "== 0x1\n" // code segment +310 // op ModR/M SIB displacement immediate +311 " 0f 8e 05 00 00 00 \n" // skip 1 instruction +312 " 05 00 00 00 01 \n" +313 " 05 00 00 00 02 \n" +314 ); +315 CHECK_TRACE_CONTENTS( +316 "run: 0x00000001 opcode: 0f\n" +317 "run: jump 5\n" +318 "run: 0x0000000c opcode: 05\n" +319 ); +320 CHECK_TRACE_DOESNT_CONTAIN("run: 0x00000007 opcode: 05"); +321 } +322 +323 :(code) +324 void test_jle_disp32_lesser() { +325 ZF = false; +326 SF = true; +327 OF = false; +328 run( +329 "== 0x1\n" // code segment +330 // op ModR/M SIB displacement immediate +331 " 0f 8e 05 00 00 00 \n" // skip 1 instruction +332 " 05 00 00 00 01 \n" +333 " 05 00 00 00 02 \n" +334 ); +335 CHECK_TRACE_CONTENTS( +336 "run: 0x00000001 opcode: 0f\n" +337 "run: jump 5\n" +338 "run: 0x0000000c opcode: 05\n" +339 ); +340 CHECK_TRACE_DOESNT_CONTAIN("run: 0x00000007 opcode: 05"); +341 } +342 +343 :(before "End Two-Byte Opcodes Starting With 0f") +344 case 0x8e: { // jump disp32 if SF or ZF +345 const int32_t offset = next32(); +346 if (ZF || SF != OF) { +347 trace(Callstack_depth+1, "run") << "jump " << NUM(offset) << end(); +348 EIP += offset; +349 } +350 break; +351 } +352 +353 :(code) +354 void test_jle_disp32_greater() { +355 ZF = false; +356 SF = false; +357 OF = false; +358 run( +359 "== 0x1\n" // code segment +360 // op ModR/M SIB displacement immediate +361 " 0f 8e 05 00 00 00 \n" // skip 1 instruction +362 " 05 00 00 00 01 \n" +363 " 05 00 00 00 02 \n" +364 ); +365 CHECK_TRACE_CONTENTS( +366 "run: 0x00000001 opcode: 0f\n" +367 "run: 0x00000007 opcode: 05\n" +368 "run: 0x0000000c opcode: 05\n" +369 ); +370 CHECK_TRACE_DOESNT_CONTAIN("run: jump 5"); +371 } -- cgit 1.4.1-2-gfad0