Repair x64 disassembler:

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 273 matching lines @@
 static const char* xmm_regs[kMaxXmmRegisters] = {
   "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
   "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15"
 };
 
 class DisassemblerX64 : public ValueObject {
  public:
   DisassemblerX64(char* buffer, intptr_t buffer_size)
       : buffer_(buffer),
         buffer_size_(buffer_size),
-        buffer_pos_(0) {
+        buffer_pos_(0),
+        rex_(0),
+        operand_size_(0),
+        group_1_prefix_(0),
+        byte_size_operand_(false) {
     buffer_[buffer_pos_] = '\0';
   }
 
   virtual ~DisassemblerX64() {
   }
 
   int InstructionDecode(uword pc);
 
  private:
   enum OperandSize {
@@ skipping 86 matching lines @@
   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);
   int FPUInstruction(uint8_t* data);
   int MemoryFPUInstruction(int escape_opcode, int regop, uint8_t* modrm_start);
   int RegisterFPUInstruction(int escape_opcode, uint8_t modrm_byte);
 
-  bool DecodeInstructionType(const InstructionDesc& idesc, uint8_t** data);
+  bool DecodeInstructionType(uint8_t** data);
 
   void UnimplementedInstruction() {
     AppendToBuffer("'Unimplemented Instruction'");
   }
 
   char* buffer_;  // Decode instructions into this buffer.
   intptr_t buffer_size_;  // The size of the buffer_.
   intptr_t buffer_pos_;  // Current character position in the buffer_.
 
   // Prefixes parsed
@@ skipping 618 matching lines @@
   if (has_register) {
     AppendToBuffer("%s st%d", mnem, modrm_byte & 0x7);
   } else {
     AppendToBuffer("%s", mnem);
   }
   return 2;
 }
 
 
 // TODO(srdjan): Should we add a branch hint argument?
-bool DisassemblerX64::DecodeInstructionType(const InstructionDesc& idesc,
-                                            uint8_t** data) {
-  uint8_t current = **data;
+bool DisassemblerX64::DecodeInstructionType(uint8_t** data) {
+  uint8_t current;
+
+  // Scan for prefixes.
+  while (true) {
+    current = **data;
+    if (current == OPERAND_SIZE_OVERRIDE_PREFIX) {  // Group 3 prefix.
+      operand_size_ = current;
+    } else if ((current & 0xF0) == 0x40) {  // REX prefix.
+      setRex(current);
+      // TODO(srdjan): Should we enable printing of REX.W?
+      // if (rex_w()) AppendToBuffer("REX.W ");
+    } else if ((current & 0xFE) == 0xF2) {  // Group 1 prefix (0xF2 or 0xF3).
+      group_1_prefix_ = current;
+    } else {  // Not a prefix - an opcode.
+      break;
+    }
+    (*data)++;
+  }
+
+  const InstructionDesc& idesc = instruction_table.Get(current);
+  byte_size_operand_ = idesc.byte_size_operation;
+
   switch (idesc.type) {
     case ZERO_OPERANDS_INSTR:
       if (current >= 0xA4 && current <= 0xA7) {
         // String move or compare operations.
         if (group_1_prefix_ == REP_PREFIX) {
           // REP.
           AppendToBuffer("rep ");
         }
         // TODO(srdjan): Should we enable printing of REX.W?
         // if (rex_w()) AppendToBuffer("REX.W ");
@@ skipping 382 matching lines @@
     case 0xBF:
       return "movsxw";
     default:
       return NULL;
   }
 }
 
 
 int DisassemblerX64::InstructionDecode(uword pc) {
   uint8_t* data = reinterpret_cast<uint8_t*>(pc);
-  uint8_t current;
 
-  // Scan for prefixes.
-  while (true) {
-    current = *data;
-    if (current == OPERAND_SIZE_OVERRIDE_PREFIX) {  // Group 3 prefix.
-      operand_size_ = current;
-    } else if ((current & 0xF0) == 0x40) {  // REX prefix.
-      setRex(current);
-      // TODO(srdjan): Should we enable printing of REX.W?
-      // if (rex_w()) AppendToBuffer("REX.W ");
-    } else if ((current & 0xFE) == 0xF2) {  // Group 1 prefix (0xF2 or 0xF3).
-      group_1_prefix_ = current;
-    } else {  // Not a prefix - an opcode.
-      break;
-    }
-    data++;
-  }
-
-  const InstructionDesc& idesc = instruction_table.Get(current);
-  byte_size_operand_ = idesc.byte_size_operation;
-  bool processed = DecodeInstructionType(idesc, &data);
+  const bool processed = DecodeInstructionType(&data);
 
   if (!processed) {
     switch (*data) {
       case 0xC2:
         AppendToBuffer("ret 0x%x", *reinterpret_cast<uint16_t*>(data + 1));
         data += 3;
         break;
 
       case 0x69:  // fall through
       case 0x6B: {
@@ skipping 351 matching lines @@
                                   human_buffer,
                                   sizeof(human_buffer),
                                   pc);
     pc += instruction_length;
   }
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64