vm: x64 disassembler fix

runtime/vm/disassembler_x64.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/disassembler.h"
 
 #include "vm/globals.h"  // Needed here to get TARGET_ARCH_IA32.
 #if defined(TARGET_ARCH_X64)
 #include "platform/utils.h"
 #include "vm/allocation.h"
@@ skipping 370 matching lines @@
                     OperandType op_order,
                     uint8_t* data);
 
   typedef const char* (DisassemblerX64::*RegisterNameMapping)(int reg) const;
 
   int PrintRightOperandHelper(uint8_t* modrmp,
                               RegisterNameMapping register_name);
   int PrintRightOperand(uint8_t* modrmp);
   int PrintRightByteOperand(uint8_t* modrmp);
   int PrintRightXMMOperand(uint8_t* modrmp);
+  void PrintDisp(int disp, const char* after);
   int PrintImmediate(uint8_t* data, OperandSize size);
+  void PrintImmediateValue(int64_t value);
   int PrintImmediateOp(uint8_t* data);
   const char* TwoByteMnemonic(uint8_t opcode);
   int TwoByteOpcodeInstruction(uint8_t* data);
 
   int F6F7Instruction(uint8_t* data);
   int ShiftInstruction(uint8_t* data);
   int JumpShort(uint8_t* data);
   int JumpConditional(uint8_t* data);
   int JumpConditionalShort(uint8_t* data);
   int SetCC(uint8_t* data);
@@ skipping 45 matching lines @@
     uint8_t* modrmp,
     RegisterNameMapping direct_register_name) {
   int mod, regop, rm;
   get_modrm(*modrmp, &mod, &regop, &rm);
   RegisterNameMapping register_name = (mod == 3) ? direct_register_name :
       &DisassemblerX64::NameOfCPURegister;
   switch (mod) {
     case 0:
       if ((rm & 7) == 5) {
         int32_t disp = *reinterpret_cast<int32_t*>(modrmp + 1);
-        AppendToBuffer("[rip%s%#x]", disp < 0 ? "-" : "+", Utils::Abs(disp));
+        AppendToBuffer("[rip");
+        PrintDisp(disp, "]");
         return 5;
       } else if ((rm & 7) == 4) {
         // Codes for SIB byte.
         uint8_t sib = *(modrmp + 1);
         int scale, index, base;
         get_sib(sib, &scale, &index, &base);
         if (index == 4 && (base & 7) == 4 && scale == 0 /*times_1*/) {
           // index == rsp means no index. Only use sib byte with no index for
           // rsp and r12 base.
           AppendToBuffer("[%s]", NameOfCPURegister(base));
           return 2;
         } else if (base == 5) {
           // base == rbp means no base register (when mod == 0).
           int32_t disp = *reinterpret_cast<int32_t*>(modrmp + 2);
-          AppendToBuffer("[%s*%d+%#x]",
-                         NameOfCPURegister(index),
-                         1 << scale, disp);
+          AppendToBuffer("[%s*%d", NameOfCPURegister(index), 1 << scale);
+          PrintDisp(disp, "]");
           return 6;
         } else if (index != 4 && base != 5) {
           // [base+index*scale]
           AppendToBuffer("[%s+%s*%d]",
                          NameOfCPURegister(base),
                          NameOfCPURegister(index),
                          1 << scale);
           return 2;
         } else {
           UnimplementedInstruction();
           return 1;
         }
       } else {
         AppendToBuffer("[%s]", NameOfCPURegister(rm));
         return 1;
       }
       break;
     case 1:  // fall through
     case 2:
       if ((rm & 7) == 4) {
         uint8_t sib = *(modrmp + 1);
         int scale, index, base;
         get_sib(sib, &scale, &index, &base);
         int disp = (mod == 2) ? *reinterpret_cast<int32_t*>(modrmp + 2)
                               : *reinterpret_cast<char*>(modrmp + 2);
         if (index == 4 && (base & 7) == 4 && scale == 0 /*times_1*/) {
-          if (-disp > 0) {
-            AppendToBuffer("[%s-%#x]", NameOfCPURegister(base), -disp);
-          } else {
-            AppendToBuffer("[%s+%#x]", NameOfCPURegister(base), disp);
-          }
+          AppendToBuffer("[%s", NameOfCPURegister(base));
+          PrintDisp(disp, "]");
         } else {
-          if (-disp > 0) {
-            AppendToBuffer("[%s+%s*%d-%#x]",
-                           NameOfCPURegister(base),
-                           NameOfCPURegister(index),
-                           1 << scale,
-                           -disp);
-          } else {
-            AppendToBuffer("[%s+%s*%d+%#x]",
-                           NameOfCPURegister(base),
-                           NameOfCPURegister(index),
-                           1 << scale,
-                           disp);
-          }
+          AppendToBuffer("[%s+%s*%d",
+                         NameOfCPURegister(base),
+                         NameOfCPURegister(index),
+                         1 << scale);
+          PrintDisp(disp, "]");
         }
         return mod == 2 ? 6 : 3;
       } else {
         // No sib.
         int disp = (mod == 2) ? *reinterpret_cast<int32_t*>(modrmp + 1)
                               : *reinterpret_cast<char*>(modrmp + 1);
-        if (-disp > 0) {
-        AppendToBuffer("[%s-%#x]", NameOfCPURegister(rm), -disp);
-        } else {
-        AppendToBuffer("[%s+%#x]", NameOfCPURegister(rm), disp);
-        }
+        AppendToBuffer("[%s", NameOfCPURegister(rm));
+        PrintDisp(disp, "]");
         return (mod == 2) ? 5 : 2;
       }
       break;
     case 3:
       AppendToBuffer("%s", (this->*register_name)(rm));
       return 1;
     default:
       UnimplementedInstruction();
       return 1;
   }
@@ skipping 19 matching lines @@
       break;
     case QUADWORD_SIZE:
       value = *reinterpret_cast<int32_t*>(data);
       count = 4;
       break;
     default:
       UNREACHABLE();
       value = 0;  // Initialize variables on all paths to satisfy the compiler.
       count = 0;
   }
-  AppendToBuffer("%#" Px64 "", value);
+  PrintImmediateValue(value);
   return count;
 }
 
+void DisassemblerX64::PrintImmediateValue(int64_t value) {
+  if (value >= 0 && value <= 9) {

[regis, 2016/04/19 20:59:22]

((value >= 0) && (value <= 9))

[sra1, 2016/04/19 23:32:39]

Done.

+    AppendToBuffer("%" Pd64 "", value);
+  } else {
+    AppendToBuffer("%#" Px64 "", value);
+  }
+}
+
+void DisassemblerX64::PrintDisp(int disp, const char* after) {
+  if (-disp > 0) {
+    AppendToBuffer("-%#x", -disp);
+  } else {
+    AppendToBuffer("+%#x", disp);
+  }
+  if (after != NULL) AppendToBuffer("%s", after);
+}
+
+
+
 
 // Returns number of bytes used by machine instruction, including *data byte.
 // Writes immediate instructions to 'tmp_buffer_'.
 int DisassemblerX64::PrintImmediateOp(uint8_t* data) {
   bool byte_size_immediate = (*data & 0x02) != 0;
   uint8_t modrm = *(data + 1);
   int mod, regop, rm;
   get_modrm(modrm, &mod, &regop, &rm);
   const char* mnem = "Imm???";
   switch (regop) {
@@ skipping 61 matching lines @@
         UnimplementedInstruction();
     }
     AppendToBuffer("%s%c %s",
                    mnem,
                    operand_size_code(),
                    NameOfCPURegister(rm));
     return 2;
   } else if (regop == 0) {
     AppendToBuffer("test%c ", operand_size_code());
     int count = PrintRightOperand(data + 1);  // Use name of 64-bit register.
-    AppendToBuffer(",0x");
+    AppendToBuffer(",");
     count += PrintImmediate(data + 1 + count, operand_size());
     return 1 + count;
   } else {
     UnimplementedInstruction();
     return 2;
   }
 }
 
 
 int DisassemblerX64::ShiftInstruction(uint8_t* data) {
@@ skipping 934 matching lines @@
 
 
 int DisassemblerX64::InstructionDecode(uword pc) {
   uint8_t* data = reinterpret_cast<uint8_t*>(pc);
 
   const bool processed = DecodeInstructionType(&data);
 
   if (!processed) {
     switch (*data) {
       case 0xC2:
-        AppendToBuffer("ret %#x", *reinterpret_cast<uint16_t*>(data + 1));
+        AppendToBuffer("ret ");
+        PrintImmediateValue(*reinterpret_cast<uint16_t*>(data + 1));
         data += 3;
         break;
 
       case 0xC8:
         AppendToBuffer("enter %d, %d",
                        *reinterpret_cast<uint16_t*>(data + 1),
                        data[3]);
         data += 4;
         break;
 
       case 0x69:  // fall through
       case 0x6B: {
         int mod, regop, rm;
         get_modrm(*(data + 1), &mod, &regop, &rm);
         int32_t imm = *data == 0x6B ? *(data + 2)
             : *reinterpret_cast<int32_t*>(data + 2);
-        AppendToBuffer("imul%c %s,%s,%#x",
+        AppendToBuffer("imul%c %s,%s,",
                        operand_size_code(),
                        NameOfCPURegister(regop),
-                       NameOfCPURegister(rm), imm);
+                       NameOfCPURegister(rm));
+        PrintImmediateValue(imm);
         data += 2 + (*data == 0x6B ? 1 : 4);
         break;
       }
 
       case 0x81:  // fall through
       case 0x83:  // 0x81 with sign extension bit set
         data += PrintImmediateOp(data);
         break;
 
       case 0x0F:
@@ skipping 46 matching lines @@
 
       case 0xC7:  // imm32, fall through
       case 0xC6:  // imm8
       {
         bool is_byte = *data == 0xC6;
         data++;
         if (is_byte) {
           AppendToBuffer("movb ");
           data += PrintRightByteOperand(data);
           int32_t imm = *data;
-          AppendToBuffer(",%#x", imm);
+          AppendToBuffer(",");
+          PrintImmediateValue(imm);
           data++;
         } else {
           AppendToBuffer("mov%c ", operand_size_code());
           data += PrintRightOperand(data);
           int32_t imm = *reinterpret_cast<int32_t*>(data);
-          AppendToBuffer(",%#x", imm);
+          AppendToBuffer(",");
+          PrintImmediateValue(imm);
           data += 4;
         }
       }
         break;
 
       case 0x80: {
         data++;
         AppendToBuffer("cmpb ");
         data += PrintRightByteOperand(data);
         int32_t imm = *data;
-        AppendToBuffer(",%#x", imm);
+        AppendToBuffer(",");
+        PrintImmediateValue(imm);
         data++;
       }
         break;
 
       case 0x88:  // 8bit, fall through
       case 0x89:  // 32bit
       {
         bool is_byte = *data == 0x88;
         int mod, regop, rm;
         data++;
@@ skipping 44 matching lines @@
       case 0xBC:
       case 0xBD:
       case 0xBE:
       case 0xBF: {
         // mov reg8,imm8 or mov reg32,imm32
         uint8_t opcode = *data;
         data++;
         uint8_t is_32bit = (opcode >= 0xB8);
         int reg = (opcode & 0x7) | (rex_b() ? 8 : 0);
         if (is_32bit) {
-          AppendToBuffer("mov%c %s, ",
+          AppendToBuffer("mov%c %s,",
                          operand_size_code(),
                          NameOfCPURegister(reg));
           data += PrintImmediate(data, DOUBLEWORD_SIZE);
         } else {
-          AppendToBuffer("movb %s, ",
+          AppendToBuffer("movb %s,",
                          NameOfByteCPURegister(reg));
           data += PrintImmediate(data, BYTE_SIZE);
         }
         break;
       }
       case 0xFE: {
         data++;
         int mod, regop, rm;
         get_modrm(*data, &mod, &regop, &rm);
         if (regop == 1) {
           AppendToBuffer("decb ");
           data += PrintRightByteOperand(data);
         } else {
           UnimplementedInstruction();
         }
         break;
       }
       case 0x68:
-        AppendToBuffer("push %#x", *reinterpret_cast<int32_t*>(data + 1));
+        AppendToBuffer("push ");
+        PrintImmediateValue(*reinterpret_cast<int32_t*>(data + 1));
         data += 5;
         break;
 
       case 0x6A:
-        AppendToBuffer("push %#x", *reinterpret_cast<int8_t*>(data + 1));
+        AppendToBuffer("push ");
+        PrintImmediateValue(*reinterpret_cast<int8_t*>(data + 1));
         data += 2;
         break;
 
       case 0xA1:  // Fall through.
       case 0xA3:
         switch (operand_size()) {
           case DOUBLEWORD_SIZE: {
             AppendAddressToBuffer(
                 reinterpret_cast<uint8_t*>(
                     *reinterpret_cast<int32_t*>(data + 1)));
@@ skipping 27 matching lines @@
             data += 9;
             break;
           }
           default:
             UnimplementedInstruction();
             data += 2;
         }
         break;
 
       case 0xA8:
-        AppendToBuffer("test al,%#x", *reinterpret_cast<uint8_t*>(data + 1));
+        AppendToBuffer("test al,");
+        PrintImmediateValue(*reinterpret_cast<uint8_t*>(data + 1));
         data += 2;
         break;
 
       case 0xA9: {
         int64_t value = 0;
         switch (operand_size()) {
           case WORD_SIZE:
             value = *reinterpret_cast<uint16_t*>(data + 1);
             data += 3;
             break;
           case DOUBLEWORD_SIZE:
             value = *reinterpret_cast<uint32_t*>(data + 1);
             data += 5;
             break;
           case QUADWORD_SIZE:
             value = *reinterpret_cast<int32_t*>(data + 1);
             data += 5;
             break;
           default:
             UNREACHABLE();
         }
-        AppendToBuffer("test%c rax,%#" Px64 "",
-                       operand_size_code(),
-                       value);
+        AppendToBuffer("test%c rax,", operand_size_code());
+        PrintImmediateValue(value);
         break;
       }
       case 0xD1:  // fall through
       case 0xD3:  // fall through
       case 0xC1:
         data += ShiftInstruction(data);
         break;
       case 0xD0:  // fall through
       case 0xD2:  // fall through
       case 0xC0:
@@ skipping 55 matching lines @@
   if (out_instr_len) {
     *out_instr_len = instruction_length;
   }
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64