Copies Simulator Debugger from ARM to MIPS.

runtime/vm/disassembler_mips.cc

 // Copyright (c) 2013, 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_MIPS.
 #if defined(TARGET_ARCH_MIPS)
 #include "platform/assert.h"
 
 namespace dart {
 
 class MIPSDecoder : public ValueObject {
  public:
   MIPSDecoder(char* buffer, size_t buffer_size)
       : buffer_(buffer),
         buffer_size_(buffer_size),
-        buffer_pos_(0) {
+        buffer_pos_(0),
+        decode_failure_(false) {
     buffer_[buffer_pos_] = '\0';
   }
 
   ~MIPSDecoder() {}
 
   // Writes one disassembled instruction into 'buffer' (0-terminated).
+  // Returns true if the instruction was successfully decoded, false otherwise.
   void InstructionDecode(Instr* instr);
 
+  void set_decode_failure(bool b) { decode_failure_ = b; }
+  bool decode_failure() const { return decode_failure_; }
+
  private:
   // Bottleneck functions to print into the out_buffer.
   void Print(const char* str);
 
   // Printing of common values.
   void PrintRegister(Register reg);
 
   int FormatRegister(Instr* instr, const char* format);
   int FormatOption(Instr* instr, const char* format);
   void Format(Instr* instr, const char* format);
+  void Unknown(Instr* instr);
 
   void DecodeSpecial(Instr* instr);
   void DecodeSpecial2(Instr* instr);
-  void DecodeSpecial3(Instr* instr);
 
   // Convenience functions.
   char* get_buffer() const { return buffer_; }
   char* current_position_in_buffer() { return buffer_ + buffer_pos_; }
   size_t remaining_size_in_buffer() { return buffer_size_ - buffer_pos_; }
 
   char* buffer_;  // Decode instructions into this buffer.
   size_t buffer_size_;  // The size of the character buffer.
   size_t buffer_pos_;  // Current character position in buffer.
 
+  bool decode_failure_;  // Set to true when a failure to decode is detected.
+
   DISALLOW_ALLOCATION();
   DISALLOW_COPY_AND_ASSIGN(MIPSDecoder);
 };
 
 
 // Support for assertions in the MIPSDecoder formatting functions.
 #define STRING_STARTS_WITH(string, compare_string) \
   (strncmp(string, compare_string, strlen(compare_string)) == 0)
 
 
@@ skipping 46 matching lines @@
 }
 
 
 // FormatOption takes a formatting string and interprets it based on
 // the current instructions. The format string points to the first
 // character of the option string (the option escape has already been
 // consumed by the caller.)  FormatOption returns the number of
 // characters that were consumed from the formatting string.
 int MIPSDecoder::FormatOption(Instr* instr, const char* format) {
   switch (format[0]) {
+    case 'c': {
+      ASSERT(STRING_STARTS_WITH(format, "code"));
+      buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
+                                remaining_size_in_buffer(),
+                                "%d", instr->BreakCodeField());
+      return 4;
+    }
     case 'h': {
       ASSERT(STRING_STARTS_WITH(format, "hint"));
-      if (instr->SaField() != 0) {
-        UNIMPLEMENTED();
+      if (instr->SaField() == 0x10) {
+        // The high bit of the SA field is the only one that means something for
+        // JALR and JR. TODO(zra): Fill in the other cases for PREF if needed.
+        buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
+                                   remaining_size_in_buffer(),
+                                   ".hb");
+      } else if (instr->SaField() != 0) {
+        buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
+                           remaining_size_in_buffer(),
+                           ".unknown");
       }
       return 4;
     }
     case 'i': {
       ASSERT(STRING_STARTS_WITH(format, "imm"));
       if (format[3] == 'u') {
         int32_t imm = instr->UImmField();
         buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
                                    remaining_size_in_buffer(),
                                    "0x%x",
@@ skipping 38 matching lines @@
       format += FormatOption(instr, format);
     } else {
       buffer_[buffer_pos_++] = cur;
     }
     cur = *format++;
   }
   buffer_[buffer_pos_]  = '\0';
 }
 
 
+// For currently unimplemented decodings the disassembler calls Unknown(instr)
+// which will just print "unknown" of the instruction bits.
+void MIPSDecoder::Unknown(Instr* instr) {
+  Format(instr, "unknown");
+  set_decode_failure(true);
+}
+
+
 void MIPSDecoder::DecodeSpecial(Instr* instr) {
   ASSERT(instr->OpcodeField() == SPECIAL);
   switch (instr->FunctionField()) {
     case ADDU: {
       Format(instr, "addu 'rd, 'rs, 'rt");
       break;
     }
     case AND: {
       Format(instr, "and 'rd, 'rs, 'rt");
       break;
     }
+    case BREAK: {
+      Format(instr, "break 'code");
+      break;
+    }
     case DIV: {
       Format(instr, "div 'rs, 'rt");
       break;
     }
     case DIVU: {
       Format(instr, "divu 'rs, 'rt");
       break;
     }
     case MFHI: {
       Format(instr, "mfhi 'rd");
       break;
     }
     case MFLO: {
       Format(instr, "mflo 'rd");
       break;
     }
     case SLL: {
       if ((instr->RdField() == R0) &&
           (instr->RtField() == R0) &&
           (instr->SaField() == 0)) {
         Format(instr, "nop");
       } else {
         Format(instr, "sll 'rd, 'rt, 'sa");
       }
       break;
     }
     case JR: {
-      ASSERT(instr->RtField() == R0);
-      ASSERT(instr->RdField() == R0);
       Format(instr, "jr'hint 'rs");
       break;
     }
     default: {
-      OS::PrintErr("DecodeSpecial: 0x%x\n", instr->InstructionBits());
-      UNREACHABLE();
+      Unknown(instr);
       break;
     }
   }
 }
 
 
 void MIPSDecoder::DecodeSpecial2(Instr* instr) {
   ASSERT(instr->OpcodeField() == SPECIAL2);
   switch (instr->FunctionField()) {
     case CLO: {
       Format(instr, "clo 'rd, 'rs");
       break;
     }
     case CLZ: {
       Format(instr, "clz 'rd, 'rs");
       break;
     }
     default: {
-      OS::PrintErr("DecodeSpecial2: 0x%x\n", instr->InstructionBits());
-      UNREACHABLE();
-      break;
-    }
-  }
-}
-
-
-void MIPSDecoder::DecodeSpecial3(Instr* instr) {
-  ASSERT(instr->OpcodeField() == SPECIAL3);
-  switch (instr->FunctionField()) {
-    default: {
-      OS::PrintErr("DecodeSpecial3: 0x%x\n", instr->InstructionBits());
-      UNREACHABLE();
+      Unknown(instr);
       break;
     }
   }
 }
 
 
 void MIPSDecoder::InstructionDecode(Instr* instr) {
   switch (instr->OpcodeField()) {
     case SPECIAL: {
       DecodeSpecial(instr);
       break;
     }
     case SPECIAL2: {
       DecodeSpecial2(instr);
       break;
     }
-    case SPECIAL3: {
-      DecodeSpecial3(instr);
-      break;
-    }
     case ADDIU: {
       Format(instr, "addiu 'rt, 'rs, 'imms");
       break;
     }
     case ANDI: {
       Format(instr, "andi 'rt, 'rs, 'immu");
       break;
     }
     case LB: {
       Format(instr, "lb 'rt, 'imms('rs)");
@@ skipping 25 matching lines @@
     }
     case SH: {
       Format(instr, "sh 'rt, 'imms('rs)");
       break;
     }
     case SW: {
       Format(instr, "sw 'rt, 'imms('rs)");
       break;
     }
     default: {
-      OS::PrintErr("Undecoded instruction: 0x%x\n", instr->InstructionBits());
-      UNREACHABLE();
+      Unknown(instr);
       break;
     }
   }
 }
 
 
-int Disassembler::DecodeInstruction(char* hex_buffer, intptr_t hex_size,
+bool Disassembler::DecodeInstruction(char* hex_buffer, intptr_t hex_size,
                                     char* human_buffer, intptr_t human_size,
-                                    uword pc) {
+                                    int *out_instr_len, uword pc) {
   MIPSDecoder decoder(human_buffer, human_size);
   Instr* instr = Instr::At(pc);
   decoder.InstructionDecode(instr);
   OS::SNPrint(hex_buffer, hex_size, "%08x", instr->InstructionBits());
-  return Instr::kInstrSize;
+  if (out_instr_len) {
+    *out_instr_len = Instr::kInstrSize;
+  }
+  return !decoder.decode_failure();
 }
 
 
-void Disassembler::Disassemble(uword start,
+bool Disassembler::Disassemble(uword start,
                                uword end,
                                DisassemblyFormatter* formatter,
                                const Code::Comments& comments) {
   ASSERT(formatter != NULL);
+  bool success = true;
   char hex_buffer[kHexadecimalBufferSize];  // Instruction in hexadecimal form.
   char human_buffer[kUserReadableBufferSize];  // Human-readable instruction.
   uword pc = start;
   intptr_t comment_finger = 0;
   while (pc < end) {
     const intptr_t offset = pc - start;
     while (comment_finger < comments.Length() &&
            comments.PCOffsetAt(comment_finger) <= offset) {
       formatter->Print(
           "        ;; %s\n",
           String::Handle(comments.CommentAt(comment_finger)).ToCString());
       comment_finger++;
     }
-    int instruction_length = DecodeInstruction(hex_buffer,
-                                               sizeof(hex_buffer),
-                                               human_buffer,
-                                               sizeof(human_buffer),
-                                               pc);
+    int instruction_length;
+    bool res = DecodeInstruction(hex_buffer, sizeof(hex_buffer),
+                                 human_buffer, sizeof(human_buffer),
+                                 &instruction_length, pc);
+    if (!res) {
+      success = false;
+    }
     formatter->ConsumeInstruction(hex_buffer,
                                   sizeof(hex_buffer),
                                   human_buffer,
                                   sizeof(human_buffer),
                                   pc);
     pc += instruction_length;
   }
+
+  return success;
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_MIPS