From 069ed1c879866673ce51dfccfb6b78f8055aeb4d Mon Sep 17 00:00:00 2001 From: Kartik Agaram Date: Fri, 27 Jul 2018 11:55:47 -0700 Subject: 4442 Clean up trace levels everywhere in SubX. --- subx/010vm.cc | 6 +++--- subx/011run.cc | 2 +- subx/012direct_addressing.cc | 42 ++++++++++++++++++++--------------------- subx/013indirect_addressing.cc | 38 ++++++++++++++++++------------------- subx/014immediate_addressing.cc | 38 ++++++++++++++++++------------------- subx/015index_addressing.cc | 8 ++++---- subx/016jump_relative.cc | 14 +++++++------- subx/017jump_relative.cc | 14 +++++++------- subx/018functions.cc | 12 ++++++------ subx/019syscalls.cc | 2 +- subx/026labels.cc | 10 +++++----- 11 files changed, 93 insertions(+), 93 deletions(-) (limited to 'subx') diff --git a/subx/010vm.cc b/subx/010vm.cc index 5ea40bbc..e89e2566 100644 --- a/subx/010vm.cc +++ b/subx/010vm.cc @@ -70,7 +70,7 @@ SF = ZF = OF = false; /* arg1 and arg2 must be signed */ \ int64_t tmp = arg1 op arg2; \ arg1 = arg1 op arg2; \ - trace(2, "run") << "storing 0x" << HEXWORD << arg1 << end(); \ + trace(90, "run") << "storing 0x" << HEXWORD << arg1 << end(); \ SF = (arg1 < 0); \ ZF = (arg1 == 0); \ OF = (arg1 != tmp); \ @@ -81,7 +81,7 @@ SF = ZF = OF = false; #define BINARY_BITWISE_OP(op, arg1, arg2) { \ /* arg1 and arg2 must be unsigned */ \ arg1 = arg1 op arg2; \ - trace(2, "run") << "storing 0x" << HEXWORD << arg1 << end(); \ + trace(90, "run") << "storing 0x" << HEXWORD << arg1 << end(); \ SF = (arg1 >> 31); \ ZF = (arg1 == 0); \ OF = false; \ @@ -146,7 +146,7 @@ inline void write_mem_i32(uint32_t addr, int32_t val) { // skeleton of how x86 instructions are decoded void run_one_instruction() { uint8_t op=0, op2=0, op3=0; - trace(2, "run") << "inst: 0x" << HEXWORD << EIP << end(); + trace(90, "run") << "inst: 0x" << HEXWORD << EIP << end(); //? cerr << "inst: 0x" << EIP << '\n'; switch (op = next()) { case 0xf4: // hlt diff --git a/subx/011run.cc b/subx/011run.cc index 2de87a72..4a754a09 100644 --- a/subx/011run.cc +++ b/subx/011run.cc @@ -237,7 +237,7 @@ put(name, "05", "add imm32 to R0 (EAX)"); :(before "End Single-Byte Opcodes") case 0x05: { // add imm32 to EAX int32_t arg2 = imm32(); - trace(2, "run") << "add imm32 0x" << HEXWORD << arg2 << " to reg EAX" << end(); + trace(90, "run") << "add imm32 0x" << HEXWORD << arg2 << " to reg EAX" << end(); BINARY_ARITHMETIC_OP(+, Reg[EAX].i, arg2); break; } diff --git a/subx/012direct_addressing.cc b/subx/012direct_addressing.cc index 66d34195..43b1137b 100644 --- a/subx/012direct_addressing.cc +++ b/subx/012direct_addressing.cc @@ -18,7 +18,7 @@ put(name, "01", "add r32 to rm32"); case 0x01: { // add r32 to r/m32 uint8_t modrm = next(); uint8_t arg2 = (modrm>>3)&0x7; - trace(2, "run") << "add " << rname(arg2) << " to r/m32" << end(); + trace(90, "run") << "add " << rname(arg2) << " to r/m32" << end(); int32_t* arg1 = effective_address(modrm); BINARY_ARITHMETIC_OP(+, *arg1, Reg[arg2].i); break; @@ -36,7 +36,7 @@ int32_t* effective_address(uint8_t modrm) { switch (mod) { case 3: // mod 3 is just register direct addressing - trace(2, "run") << "r/m32 is " << rname(rm) << end(); + trace(90, "run") << "r/m32 is " << rname(rm) << end(); return &Reg[rm].i; // End Mod Special-cases(addr) default: @@ -81,7 +81,7 @@ put(name, "29", "subtract r32 from rm32"); case 0x29: { // subtract r32 from r/m32 uint8_t modrm = next(); uint8_t arg2 = (modrm>>3)&0x7; - trace(2, "run") << "subtract " << rname(arg2) << " from r/m32" << end(); + trace(90, "run") << "subtract " << rname(arg2) << " from r/m32" << end(); int32_t* arg1 = effective_address(modrm); BINARY_ARITHMETIC_OP(-, *arg1, Reg[arg2].i); break; @@ -107,7 +107,7 @@ put(name, "21", "rm32 = bitwise AND of r32 with rm32"); case 0x21: { // and r32 with r/m32 uint8_t modrm = next(); uint8_t arg2 = (modrm>>3)&0x7; - trace(2, "run") << "and " << rname(arg2) << " with r/m32" << end(); + trace(90, "run") << "and " << rname(arg2) << " with r/m32" << end(); int32_t* arg1 = effective_address(modrm); BINARY_BITWISE_OP(&, *arg1, Reg[arg2].u); break; @@ -133,7 +133,7 @@ put(name, "09", "rm32 = bitwise OR of r32 with rm32"); case 0x09: { // or r32 with r/m32 uint8_t modrm = next(); uint8_t arg2 = (modrm>>3)&0x7; - trace(2, "run") << "or " << rname(arg2) << " with r/m32" << end(); + trace(90, "run") << "or " << rname(arg2) << " with r/m32" << end(); int32_t* arg1 = effective_address(modrm); BINARY_BITWISE_OP(|, *arg1, Reg[arg2].u); break; @@ -159,7 +159,7 @@ put(name, "31", "rm32 = bitwise XOR of r32 with rm32"); case 0x31: { // xor r32 with r/m32 uint8_t modrm = next(); uint8_t arg2 = (modrm>>3)&0x7; - trace(2, "run") << "xor " << rname(arg2) << " with r/m32" << end(); + trace(90, "run") << "xor " << rname(arg2) << " with r/m32" << end(); int32_t* arg1 = effective_address(modrm); BINARY_BITWISE_OP(^, *arg1, Reg[arg2].u); break; @@ -183,10 +183,10 @@ put(name, "f7", "bitwise complement of rm32"); :(before "End Single-Byte Opcodes") case 0xf7: { // xor r32 with r/m32 uint8_t modrm = next(); - trace(2, "run") << "'not' of r/m32" << end(); + trace(90, "run") << "'not' of r/m32" << end(); int32_t* arg1 = effective_address(modrm); *arg1 = ~(*arg1); - trace(2, "run") << "storing 0x" << HEXWORD << *arg1 << end(); + trace(90, "run") << "storing 0x" << HEXWORD << *arg1 << end(); SF = (*arg1 >> 31); ZF = (*arg1 == 0); OF = false; @@ -213,7 +213,7 @@ put(name, "39", "set SF if rm32 < r32"); case 0x39: { // set SF if r/m32 < r32 uint8_t modrm = next(); uint8_t reg2 = (modrm>>3)&0x7; - trace(2, "run") << "compare " << rname(reg2) << " with r/m32" << end(); + trace(90, "run") << "compare " << rname(reg2) << " with r/m32" << end(); int32_t* arg1 = effective_address(modrm); int32_t arg2 = Reg[reg2].i; int32_t tmp1 = *arg1 - arg2; @@ -221,7 +221,7 @@ case 0x39: { // set SF if r/m32 < r32 ZF = (tmp1 == 0); int64_t tmp2 = *arg1 - arg2; OF = (tmp1 != tmp2); - trace(2, "run") << "SF=" << SF << "; ZF=" << ZF << "; OF=" << OF << end(); + trace(90, "run") << "SF=" << SF << "; ZF=" << ZF << "; OF=" << OF << end(); break; } @@ -266,10 +266,10 @@ put(name, "89", "copy r32 to rm32"); case 0x89: { // copy r32 to r/m32 uint8_t modrm = next(); uint8_t reg2 = (modrm>>3)&0x7; - trace(2, "run") << "copy " << rname(reg2) << " to r/m32" << end(); + trace(90, "run") << "copy " << rname(reg2) << " to r/m32" << end(); int32_t* arg1 = effective_address(modrm); *arg1 = Reg[reg2].i; - trace(2, "run") << "storing 0x" << HEXWORD << *arg1 << end(); + trace(90, "run") << "storing 0x" << HEXWORD << *arg1 << end(); break; } @@ -294,13 +294,13 @@ put(name, "87", "swap the contents of r32 and rm32"); case 0x87: { // exchange r32 with r/m32 uint8_t modrm = next(); uint8_t reg2 = (modrm>>3)&0x7; - trace(2, "run") << "exchange " << rname(reg2) << " with r/m32" << end(); + trace(90, "run") << "exchange " << rname(reg2) << " with r/m32" << end(); int32_t* arg1 = effective_address(modrm); int32_t tmp = *arg1; *arg1 = Reg[reg2].i; Reg[reg2].i = tmp; - trace(2, "run") << "storing 0x" << HEXWORD << *arg1 << " in r/m32" << end(); - trace(2, "run") << "storing 0x" << HEXWORD << Reg[reg2].i << " in " << rname(reg2) << end(); + trace(90, "run") << "storing 0x" << HEXWORD << *arg1 << " in r/m32" << end(); + trace(90, "run") << "storing 0x" << HEXWORD << Reg[reg2].i << " in " << rname(reg2) << end(); break; } @@ -336,15 +336,15 @@ case 0x55: case 0x56: case 0x57: { // push r32 to stack uint8_t reg = op & 0x7; - trace(2, "run") << "push " << rname(reg) << end(); + trace(90, "run") << "push " << rname(reg) << end(); push(Reg[reg].u); break; } :(code) void push(uint32_t val) { Reg[ESP].u -= 4; - trace(2, "run") << "decrementing ESP to 0x" << HEXWORD << Reg[ESP].u << end(); - trace(2, "run") << "pushing value 0x" << HEXWORD << val << end(); + trace(90, "run") << "decrementing ESP to 0x" << HEXWORD << Reg[ESP].u << end(); + trace(90, "run") << "pushing value 0x" << HEXWORD << val << end(); write_mem_u32(Reg[ESP].u, val); } @@ -382,15 +382,15 @@ case 0x5d: case 0x5e: case 0x5f: { // pop stack into r32 uint8_t reg = op & 0x7; - trace(2, "run") << "pop into " << rname(reg) << end(); + trace(90, "run") << "pop into " << rname(reg) << end(); Reg[reg].u = pop(); break; } :(code) uint32_t pop() { uint32_t result = read_mem_u32(Reg[ESP].u); - trace(2, "run") << "popping value 0x" << HEXWORD << result << end(); + trace(90, "run") << "popping value 0x" << HEXWORD << result << end(); Reg[ESP].u += 4; - trace(2, "run") << "incrementing ESP to 0x" << HEXWORD << Reg[ESP].u << end(); + trace(90, "run") << "incrementing ESP to 0x" << HEXWORD << Reg[ESP].u << end(); return result; } diff --git a/subx/013indirect_addressing.cc b/subx/013indirect_addressing.cc index e908e17c..ede192fc 100644 --- a/subx/013indirect_addressing.cc +++ b/subx/013indirect_addressing.cc @@ -18,7 +18,7 @@ case 0: // indirect addressing switch (rm) { default: // address in register - trace(2, "run") << "effective address is 0x" << std::hex << Reg[rm].u << " (" << rname(rm) << ")" << end(); + trace(90, "run") << "effective address is 0x" << std::hex << Reg[rm].u << " (" << rname(rm) << ")" << end(); addr = Reg[rm].u; break; // End Mod 0 Special-cases(addr) @@ -47,7 +47,7 @@ put(name, "03", "add rm32 to r32"); case 0x03: { // add r/m32 to r32 uint8_t modrm = next(); uint8_t arg1 = (modrm>>3)&0x7; - trace(2, "run") << "add r/m32 to " << rname(arg1) << end(); + trace(90, "run") << "add r/m32 to " << rname(arg1) << end(); const int32_t* arg2 = effective_address(modrm); BINARY_ARITHMETIC_OP(+, Reg[arg1].i, *arg2); break; @@ -90,7 +90,7 @@ put(name, "2b", "subtract rm32 from r32"); case 0x2b: { // subtract r/m32 from r32 uint8_t modrm = next(); uint8_t arg1 = (modrm>>3)&0x7; - trace(2, "run") << "subtract r/m32 from " << rname(arg1) << end(); + trace(90, "run") << "subtract r/m32 from " << rname(arg1) << end(); const int32_t* arg2 = effective_address(modrm); BINARY_ARITHMETIC_OP(-, Reg[arg1].i, *arg2); break; @@ -133,7 +133,7 @@ ff 00 00 00 # 0xff case 0x23: { // and r/m32 with r32 uint8_t modrm = next(); uint8_t arg1 = (modrm>>3)&0x7; - trace(2, "run") << "and r/m32 with " << rname(arg1) << end(); + trace(90, "run") << "and r/m32 with " << rname(arg1) << end(); const int32_t* arg2 = effective_address(modrm); BINARY_BITWISE_OP(&, Reg[arg1].u, *arg2); break; @@ -176,7 +176,7 @@ put(name, "0b", "r32 = bitwise OR of r32 with rm32"); case 0x0b: { // or r/m32 with r32 uint8_t modrm = next(); uint8_t arg1 = (modrm>>3)&0x7; - trace(2, "run") << "or r/m32 with " << rname(arg1) << end(); + trace(90, "run") << "or r/m32 with " << rname(arg1) << end(); const int32_t* arg2 = effective_address(modrm); BINARY_BITWISE_OP(|, Reg[arg1].u, *arg2); break; @@ -219,7 +219,7 @@ put(name, "33", "r32 = bitwise XOR of r32 with rm32"); case 0x33: { // xor r/m32 with r32 uint8_t modrm = next(); uint8_t arg1 = (modrm>>3)&0x7; - trace(2, "run") << "xor r/m32 with " << rname(arg1) << end(); + trace(90, "run") << "xor r/m32 with " << rname(arg1) << end(); const int32_t* arg2 = effective_address(modrm); BINARY_BITWISE_OP(|, Reg[arg1].u, *arg2); break; @@ -302,7 +302,7 @@ put(name, "3b", "set SF if rm32 > r32"); case 0x3b: { // set SF if r32 < r/m32 uint8_t modrm = next(); uint8_t reg1 = (modrm>>3)&0x7; - trace(2, "run") << "compare r/m32 with " << rname(reg1) << end(); + trace(90, "run") << "compare r/m32 with " << rname(reg1) << end(); int32_t arg1 = Reg[reg1].i; int32_t* arg2 = effective_address(modrm); int32_t tmp1 = arg1 - *arg2; @@ -310,7 +310,7 @@ case 0x3b: { // set SF if r32 < r/m32 ZF = (tmp1 == 0); int64_t tmp2 = arg1 - *arg2; OF = (tmp1 != tmp2); - trace(2, "run") << "SF=" << SF << "; ZF=" << ZF << "; OF=" << OF << end(); + trace(90, "run") << "SF=" << SF << "; ZF=" << ZF << "; OF=" << OF << end(); break; } @@ -374,10 +374,10 @@ af 00 00 00 # 0xaf case 0x8b: { // copy r32 to r/m32 uint8_t modrm = next(); uint8_t reg1 = (modrm>>3)&0x7; - trace(2, "run") << "copy r/m32 to " << rname(reg1) << end(); + trace(90, "run") << "copy r/m32 to " << rname(reg1) << end(); int32_t* arg2 = effective_address(modrm); Reg[reg1].i = *arg2; - trace(2, "run") << "storing 0x" << HEXWORD << *arg2 << end(); + trace(90, "run") << "storing 0x" << HEXWORD << *arg2 << end(); break; } @@ -409,10 +409,10 @@ case 0xff: { uint8_t subop = (modrm>>3)&0x7; // middle 3 'reg opcode' bits switch (subop) { case 4: { // jump to r/m32 - trace(2, "run") << "jump to r/m32" << end(); + trace(90, "run") << "jump to r/m32" << end(); int32_t* arg2 = effective_address(modrm); EIP = *arg2; - trace(2, "run") << "jumping to 0x" << HEXWORD << EIP << end(); + trace(90, "run") << "jumping to 0x" << HEXWORD << EIP << end(); break; } // End Op ff Subops @@ -438,7 +438,7 @@ af 00 00 00 # 0xaf :(before "End Op ff Subops") case 6: { // push r/m32 to stack - trace(2, "run") << "push r/m32" << end(); + trace(90, "run") << "push r/m32" << end(); const int32_t* val = effective_address(modrm); push(*val); break; @@ -469,7 +469,7 @@ case 0x8f: { // pop stack into r/m32 uint8_t subop = (modrm>>3)&0x7; switch (subop) { case 0: { - trace(2, "run") << "pop into r/m32" << end(); + trace(90, "run") << "pop into r/m32" << end(); int32_t* dest = effective_address(modrm); *dest = pop(); break; @@ -495,7 +495,7 @@ case 0x8f: { // pop stack into r/m32 :(before "End Mod 0 Special-cases(addr)") case 5: // exception: mod 0b00 rm 0b101 => incoming disp32 addr = imm32(); - trace(2, "run") << "effective address is 0x" << std::hex << addr << " (disp32)" << end(); + trace(90, "run") << "effective address is 0x" << std::hex << addr << " (disp32)" << end(); break; //: @@ -519,13 +519,13 @@ case 1: // indirect + disp8 addressing switch (rm) { default: addr = Reg[rm].u; - trace(2, "run") << "effective address is initially 0x" << std::hex << addr << " (" << rname(rm) << ")" << end(); + trace(90, "run") << "effective address is initially 0x" << std::hex << addr << " (" << rname(rm) << ")" << end(); break; // End Mod 1 Special-cases(addr) } if (addr > 0) { addr += static_cast(next()); - trace(2, "run") << "effective address is 0x" << std::hex << addr << " (after adding disp8)" << end(); + trace(90, "run") << "effective address is 0x" << std::hex << addr << " (after adding disp8)" << end(); } break; @@ -564,13 +564,13 @@ case 2: // indirect + disp32 addressing switch (rm) { default: addr = Reg[rm].u; - trace(2, "run") << "effective address is initially 0x" << std::hex << addr << " (" << rname(rm) << ")" << end(); + trace(90, "run") << "effective address is initially 0x" << std::hex << addr << " (" << rname(rm) << ")" << end(); break; // End Mod 2 Special-cases(addr) } if (addr > 0) { addr += imm32(); - trace(2, "run") << "effective address is 0x" << std::hex << addr << " (after adding disp32)" << end(); + trace(90, "run") << "effective address is 0x" << std::hex << addr << " (after adding disp32)" << end(); } break; diff --git a/subx/014immediate_addressing.cc b/subx/014immediate_addressing.cc index 8c308a80..165cc446 100644 --- a/subx/014immediate_addressing.cc +++ b/subx/014immediate_addressing.cc @@ -18,12 +18,12 @@ put(name, "81", "combine rm32 with imm32 based on subop"); case 0x81: { // combine imm32 with r/m32 uint8_t modrm = next(); int32_t arg2 = imm32(); - trace(2, "run") << "combine imm32 0x" << HEXWORD << arg2 << " with r/m32" << end(); + trace(90, "run") << "combine imm32 0x" << HEXWORD << arg2 << " with r/m32" << end(); int32_t* arg1 = effective_address(modrm); uint8_t subop = (modrm>>3)&0x7; // middle 3 'reg opcode' bits switch (subop) { case 0: - trace(2, "run") << "subop add" << end(); + trace(90, "run") << "subop add" << end(); BINARY_ARITHMETIC_OP(+, *arg1, arg2); break; // End Op 81 Subops @@ -65,7 +65,7 @@ put(name, "2d", "subtract imm32 from R0 (EAX)"); :(before "End Single-Byte Opcodes") case 0x2d: { // subtract imm32 from EAX int32_t arg2 = imm32(); - trace(2, "run") << "subtract imm32 0x" << HEXWORD << arg2 << " from EAX" << end(); + trace(90, "run") << "subtract imm32 0x" << HEXWORD << arg2 << " from EAX" << end(); BINARY_ARITHMETIC_OP(-, Reg[EAX].i, arg2); break; } @@ -87,7 +87,7 @@ case 0x2d: { // subtract imm32 from EAX :(before "End Op 81 Subops") case 5: { - trace(2, "run") << "subop subtract" << end(); + trace(90, "run") << "subop subtract" << end(); BINARY_ARITHMETIC_OP(-, *arg1, arg2); break; } @@ -121,7 +121,7 @@ put(name, "25", "R0 = bitwise AND of imm32 with R0 (EAX)"); :(before "End Single-Byte Opcodes") case 0x25: { // and imm32 with EAX int32_t arg2 = imm32(); - trace(2, "run") << "and imm32 0x" << HEXWORD << arg2 << " with EAX" << end(); + trace(90, "run") << "and imm32 0x" << HEXWORD << arg2 << " with EAX" << end(); BINARY_BITWISE_OP(&, Reg[EAX].i, arg2); break; } @@ -143,7 +143,7 @@ ff 00 00 00 # 0xff :(before "End Op 81 Subops") case 4: { - trace(2, "run") << "subop and" << end(); + trace(90, "run") << "subop and" << end(); BINARY_BITWISE_OP(&, *arg1, arg2); break; } @@ -177,7 +177,7 @@ put(name, "0d", "R0 = bitwise OR of imm32 with R0 (EAX)"); :(before "End Single-Byte Opcodes") case 0x0d: { // or imm32 with EAX int32_t arg2 = imm32(); - trace(2, "run") << "or imm32 0x" << HEXWORD << arg2 << " with EAX" << end(); + trace(90, "run") << "or imm32 0x" << HEXWORD << arg2 << " with EAX" << end(); BINARY_BITWISE_OP(|, Reg[EAX].i, arg2); break; } @@ -199,7 +199,7 @@ a0 b0 c0 d0 # 0xd0c0b0a0 :(before "End Op 81 Subops") case 1: { - trace(2, "run") << "subop or" << end(); + trace(90, "run") << "subop or" << end(); BINARY_BITWISE_OP(|, *arg1, arg2); break; } @@ -231,7 +231,7 @@ put(name, "35", "R0 = bitwise XOR of imm32 with R0 (EAX)"); :(before "End Single-Byte Opcodes") case 0x35: { // xor imm32 with EAX int32_t arg2 = imm32(); - trace(2, "run") << "xor imm32 0x" << HEXWORD << arg2 << " with EAX" << end(); + trace(90, "run") << "xor imm32 0x" << HEXWORD << arg2 << " with EAX" << end(); BINARY_BITWISE_OP(^, Reg[EAX].i, arg2); break; } @@ -253,7 +253,7 @@ a0 b0 c0 d0 # 0xd0c0b0a0 :(before "End Op 81 Subops") case 6: { - trace(2, "run") << "subop xor" << end(); + trace(90, "run") << "subop xor" << end(); BINARY_BITWISE_OP(^, *arg1, arg2); break; } @@ -286,13 +286,13 @@ put(name, "3d", "subtract imm32 from R0 (EAX)"); case 0x3d: { // subtract imm32 from EAX int32_t arg1 = Reg[EAX].i; int32_t arg2 = imm32(); - trace(2, "run") << "compare EAX and imm32 0x" << HEXWORD << arg2 << end(); + trace(90, "run") << "compare EAX and imm32 0x" << HEXWORD << arg2 << end(); int32_t tmp1 = arg1 - arg2; SF = (tmp1 < 0); ZF = (tmp1 == 0); int64_t tmp2 = arg1 - arg2; OF = (tmp1 != tmp2); - trace(2, "run") << "SF=" << SF << "; ZF=" << ZF << "; OF=" << OF << end(); + trace(90, "run") << "SF=" << SF << "; ZF=" << ZF << "; OF=" << OF << end(); break; } @@ -326,13 +326,13 @@ case 0x3d: { // subtract imm32 from EAX :(before "End Op 81 Subops") case 7: { - trace(2, "run") << "subop compare" << end(); + trace(90, "run") << "subop compare" << end(); int32_t tmp1 = *arg1 - arg2; SF = (tmp1 < 0); ZF = (tmp1 == 0); int64_t tmp2 = *arg1 - arg2; OF = (tmp1 != tmp2); - trace(2, "run") << "SF=" << SF << "; ZF=" << ZF << "; OF=" << OF << end(); + trace(90, "run") << "SF=" << SF << "; ZF=" << ZF << "; OF=" << OF << end(); break; } @@ -422,7 +422,7 @@ case 0xbe: case 0xbf: { // copy imm32 to r32 uint8_t reg1 = op & 0x7; int32_t arg2 = imm32(); - trace(2, "run") << "copy imm32 0x" << HEXWORD << arg2 << " to " << rname(reg1) << end(); + trace(90, "run") << "copy imm32 0x" << HEXWORD << arg2 << " to " << rname(reg1) << end(); Reg[reg1].i = arg2; break; } @@ -445,7 +445,7 @@ put(name, "c7", "copy imm32 to rm32"); case 0xc7: { // copy imm32 to r32 uint8_t modrm = next(); int32_t arg2 = imm32(); - trace(2, "run") << "copy imm32 0x" << HEXWORD << arg2 << " to r/m32" << end(); + trace(90, "run") << "copy imm32 0x" << HEXWORD << arg2 << " to r/m32" << end(); int32_t* arg1 = effective_address(modrm); *arg1 = arg2; break; @@ -468,10 +468,10 @@ put(name, "68", "push imm32 to stack"); :(before "End Single-Byte Opcodes") case 0x68: { int32_t val = imm32(); - trace(2, "run") << "push imm32 0x" << HEXWORD << val << end(); + trace(90, "run") << "push imm32 0x" << HEXWORD << val << end(); Reg[ESP].u -= 4; write_mem_i32(Reg[ESP].u, val); - trace(2, "run") << "ESP is now 0x" << HEXWORD << Reg[ESP].u << end(); - trace(2, "run") << "contents at ESP: 0x" << HEXWORD << read_mem_u32(Reg[ESP].u) << end(); + trace(90, "run") << "ESP is now 0x" << HEXWORD << Reg[ESP].u << end(); + trace(90, "run") << "contents at ESP: 0x" << HEXWORD << read_mem_u32(Reg[ESP].u) << end(); break; } diff --git a/subx/015index_addressing.cc b/subx/015index_addressing.cc index 13287709..b1b7e563 100644 --- a/subx/015index_addressing.cc +++ b/subx/015index_addressing.cc @@ -26,22 +26,22 @@ uint32_t effective_address_from_sib(uint8_t mod) { uint32_t addr = 0; if (base != EBP || mod != 0) { addr = Reg[base].u; - trace(2, "run") << "effective address is initially 0x" << std::hex << addr << " (" << rname(base) << ")" << end(); + trace(90, "run") << "effective address is initially 0x" << std::hex << addr << " (" << rname(base) << ")" << end(); } else { // base == EBP && mod == 0 addr = imm32(); // ignore base - trace(2, "run") << "effective address is initially 0x" << std::hex << addr << " (disp32)" << end(); + trace(90, "run") << "effective address is initially 0x" << std::hex << addr << " (disp32)" << end(); } uint8_t index = (sib>>3)&0x7; if (index == ESP) { // ignore index and scale - trace(2, "run") << "effective address is 0x" << std::hex << addr << end(); + trace(90, "run") << "effective address is 0x" << std::hex << addr << end(); } else { uint8_t scale = (1 << (sib>>6)); addr += Reg[index].i*scale; // treat index register as signed. Maybe base as well? But we'll always ensure it's non-negative. - trace(2, "run") << "effective address is 0x" << std::hex << addr << " (after adding " << rname(index) << "*" << NUM(scale) << ")" << end(); + trace(90, "run") << "effective address is 0x" << std::hex << addr << " (after adding " << rname(index) << "*" << NUM(scale) << ")" << end(); } return addr; } diff --git a/subx/016jump_relative.cc b/subx/016jump_relative.cc index 48105414..57424215 100644 --- a/subx/016jump_relative.cc +++ b/subx/016jump_relative.cc @@ -19,7 +19,7 @@ put(name, "eb", "jump disp8 bytes away"); :(before "End Single-Byte Opcodes") case 0xeb: { // jump rel8 int8_t offset = static_cast(next()); - trace(2, "run") << "jump " << NUM(offset) << end(); + trace(90, "run") << "jump " << NUM(offset) << end(); EIP += offset; break; } @@ -45,7 +45,7 @@ put(name, "74", "jump disp8 bytes away if ZF is set"); case 0x74: { // jump rel8 if ZF int8_t offset = static_cast(next()); if (ZF) { - trace(2, "run") << "jump " << NUM(offset) << end(); + trace(90, "run") << "jump " << NUM(offset) << end(); EIP += offset; } break; @@ -84,7 +84,7 @@ put(name, "75", "jump disp8 bytes away if ZF is not set"); case 0x75: { // jump rel8 unless ZF int8_t offset = static_cast(next()); if (!ZF) { - trace(2, "run") << "jump " << NUM(offset) << end(); + trace(90, "run") << "jump " << NUM(offset) << end(); EIP += offset; } break; @@ -125,7 +125,7 @@ put(name, "7f", "jump disp8 bytes away if greater (ZF is unset, SF == OF)"); case 0x7f: { // jump rel8 if !SF and !ZF int8_t offset = static_cast(next()); if (!ZF && SF == OF) { - trace(2, "run") << "jump " << NUM(offset) << end(); + trace(90, "run") << "jump " << NUM(offset) << end(); EIP += offset; } break; @@ -167,7 +167,7 @@ put(name, "7d", "jump disp8 bytes away if greater or equal (SF == OF)"); case 0x7d: { // jump rel8 if !SF int8_t offset = static_cast(next()); if (SF == OF) { - trace(2, "run") << "jump " << NUM(offset) << end(); + trace(90, "run") << "jump " << NUM(offset) << end(); EIP += offset; } break; @@ -209,7 +209,7 @@ put(name, "7c", "jump disp8 bytes away if lesser (SF != OF)"); case 0x7c: { // jump rel8 if SF and !ZF int8_t offset = static_cast(next()); if (SF != OF) { - trace(2, "run") << "jump " << NUM(offset) << end(); + trace(90, "run") << "jump " << NUM(offset) << end(); EIP += offset; } break; @@ -266,7 +266,7 @@ put(name, "7e", "jump disp8 bytes away if lesser or equal (ZF is set or SF != OF case 0x7e: { // jump rel8 if SF or ZF int8_t offset = static_cast(next()); if (ZF || SF != OF) { - trace(2, "run") << "jump " << NUM(offset) << end(); + trace(90, "run") << "jump " << NUM(offset) << end(); EIP += offset; } break; diff --git a/subx/017jump_relative.cc b/subx/017jump_relative.cc index e13c1ac7..1cbb50a4 100644 --- a/subx/017jump_relative.cc +++ b/subx/017jump_relative.cc @@ -19,7 +19,7 @@ put(name, "e9", "jump disp16 bytes away"); :(before "End Single-Byte Opcodes") case 0xe9: { // jump rel8 int16_t offset = imm16(); - trace(2, "run") << "jump " << offset << end(); + trace(90, "run") << "jump " << offset << end(); EIP += offset; break; } @@ -51,7 +51,7 @@ put(name_0f, "84", "jump disp16 bytes away if ZF is set"); case 0x84: { // jump rel16 if ZF int8_t offset = imm16(); if (ZF) { - trace(2, "run") << "jump " << NUM(offset) << end(); + trace(90, "run") << "jump " << NUM(offset) << end(); EIP += offset; } break; @@ -90,7 +90,7 @@ put(name_0f, "85", "jump disp16 bytes away if ZF is not set"); case 0x85: { // jump rel16 unless ZF int8_t offset = imm16(); if (!ZF) { - trace(2, "run") << "jump " << NUM(offset) << end(); + trace(90, "run") << "jump " << NUM(offset) << end(); EIP += offset; } break; @@ -131,7 +131,7 @@ put(name_0f, "8f", "jump disp16 bytes away if greater (ZF is unset, SF == OF)"); case 0x8f: { // jump rel16 if !SF and !ZF int8_t offset = imm16(); if (!ZF && SF == OF) { - trace(2, "run") << "jump " << NUM(offset) << end(); + trace(90, "run") << "jump " << NUM(offset) << end(); EIP += offset; } break; @@ -173,7 +173,7 @@ put(name_0f, "8d", "jump disp16 bytes away if greater or equal (SF == OF)"); case 0x8d: { // jump rel16 if !SF int8_t offset = imm16(); if (SF == OF) { - trace(2, "run") << "jump " << NUM(offset) << end(); + trace(90, "run") << "jump " << NUM(offset) << end(); EIP += offset; } break; @@ -215,7 +215,7 @@ put(name_0f, "8c", "jump disp16 bytes away if lesser (SF != OF)"); case 0x8c: { // jump rel16 if SF and !ZF int8_t offset = imm16(); if (SF != OF) { - trace(2, "run") << "jump " << NUM(offset) << end(); + trace(90, "run") << "jump " << NUM(offset) << end(); EIP += offset; } break; @@ -272,7 +272,7 @@ put(name_0f, "8e", "jump disp16 bytes away if lesser or equal (ZF is set or SF ! case 0x8e: { // jump rel16 if SF or ZF int8_t offset = imm16(); if (ZF || SF != OF) { - trace(2, "run") << "jump " << NUM(offset) << end(); + trace(90, "run") << "jump " << NUM(offset) << end(); EIP += offset; } break; diff --git a/subx/018functions.cc b/subx/018functions.cc index d7401716..a557abf5 100644 --- a/subx/018functions.cc +++ b/subx/018functions.cc @@ -17,10 +17,10 @@ put(name, "e8", "call disp32"); :(before "End Single-Byte Opcodes") case 0xe8: { // call disp32 relative to next EIP int32_t offset = imm32(); - trace(2, "run") << "call imm32 0x" << HEXWORD << offset << end(); + trace(90, "run") << "call imm32 0x" << HEXWORD << offset << end(); push(EIP); EIP += offset; - trace(2, "run") << "jumping to 0x" << HEXWORD << EIP << end(); + trace(90, "run") << "jumping to 0x" << HEXWORD << EIP << end(); break; } @@ -41,11 +41,11 @@ case 0xe8: { // call disp32 relative to next EIP :(before "End Op ff Subops") case 2: { // call function pointer at r/m32 - trace(2, "run") << "call to r/m32" << end(); + trace(90, "run") << "call to r/m32" << end(); int32_t* offset = effective_address(modrm); push(EIP); EIP += *offset; - trace(2, "run") << "jumping to 0x" << HEXWORD << EIP << end(); + trace(90, "run") << "jumping to 0x" << HEXWORD << EIP << end(); break; } @@ -82,8 +82,8 @@ put(name, "c3", "return from most recent unfinished call"); :(before "End Single-Byte Opcodes") case 0xc3: { // return from a call - trace(2, "run") << "return" << end(); + trace(90, "run") << "return" << end(); EIP = pop(); - trace(2, "run") << "jumping to 0x" << HEXWORD << EIP << end(); + trace(90, "run") << "jumping to 0x" << HEXWORD << EIP << end(); break; } diff --git a/subx/019syscalls.cc b/subx/019syscalls.cc index 33972417..4e6d5888 100644 --- a/subx/019syscalls.cc +++ b/subx/019syscalls.cc @@ -3,7 +3,7 @@ put(name, "cd", "software interrupt"); :(before "End Single-Byte Opcodes") case 0xcd: { // int imm8 (software interrupt) - trace(2, "run") << "syscall" << end(); + trace(90, "run") << "syscall" << end(); uint8_t code = next(); if (code != 0x80) { raise << "Unimplemented interrupt code " << HEXBYTE << code << '\n' << end(); diff --git a/subx/026labels.cc b/subx/026labels.cc index 97d5429d..fc52fe74 100644 --- a/subx/026labels.cc +++ b/subx/026labels.cc @@ -9,7 +9,7 @@ # 1-3 bytes 3 bits 2 bits 3 bits 3 bits 3 bits 2 bits 2 bits 0/1/2/4 bytes 0/1/2/4 bytes loop: 05 0x0d0c0b0a/imm32 # add to EAX -+label: label 'loop' is at address 1 ++translate: label 'loop' is at address 1 :(before "End One-time Setup") Transform.push_back(replace_labels); @@ -53,7 +53,7 @@ void compute_addresses_for_labels(const segment& code, map add raise << "'" << to_string(inst) << "': labels can only be the first word in a line.\n" << end(); string label = curr.data.substr(0, SIZE(curr.data)-1); put(address, label, current_byte); - trace(99, "label") << "label '" << label << "' is at address " << (current_byte+code.start) << end(); + trace(99, "translate") << "label '" << label << "' is at address " << (current_byte+code.start) << end(); // no modifying current_byte; label definitions won't be in the final binary } } @@ -90,6 +90,6 @@ loop2: 05 0x0d0c0b0a/imm32 # add to EAX loop3: f -+label: label 'loop' is at address 1 -+label: label 'loop2' is at address 1 -+label: label 'loop3' is at address 6 ++translate: label 'loop' is at address 1 ++translate: label 'loop2' is at address 1 ++translate: label 'loop3' is at address 6 -- cgit 1.4.1-2-gfad0