Adds some floating point instructions to MIPS simulator, assembler, disassembler.

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"
 
@@ skipping 13 matching lines @@
   // Writes one disassembled instruction into 'buffer' (0-terminated).
   // Returns true if the instruction was successfully decoded, false otherwise.
   void InstructionDecode(Instr* instr);
 
  private:
   // Bottleneck functions to print into the out_buffer.
   void Print(const char* str);
 
   // Printing of common values.
   void PrintRegister(Register reg);
+  void PrintFRegister(FRegister reg);
+  void PrintFormat(Instr* instr);
 
   int FormatRegister(Instr* instr, const char* format);
+  int FormatFRegister(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 DecodeRegImm(Instr* instr);
+  void DecodeCop1(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.
 
@@ skipping 19 matching lines @@
 
 
 static const char* reg_names[kNumberOfCpuRegisters] = {
   "r0" , "r1" , "r2" , "r3" , "r4" , "r5" , "r6" , "r7" ,
   "r8" , "r9" , "r10", "r11", "r12", "r13", "r14", "r15",
   "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
   "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
 };
 
 
+static const char* freg_names[kNumberOfFRegisters] = {
+  "f0" , "f1" , "f2" , "f3" , "f4" , "f5" , "f6" , "f7" ,
+  "f8" , "f9" , "f10", "f11", "f12", "f13", "f14", "f15",
+  "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
+  "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
+};
+
+
 void MIPSDecoder::PrintRegister(Register reg) {
   ASSERT(0 <= reg);
   ASSERT(reg < kNumberOfCpuRegisters);
   Print(reg_names[reg]);
 }
 
 
+void MIPSDecoder::PrintFRegister(FRegister reg) {
+  ASSERT(0 <= reg);
+  ASSERT(reg < kNumberOfFRegisters);
+  Print(freg_names[reg]);
+}
+
+
 // Handle all register based formatting in these functions to reduce the
 // complexity of FormatOption.
 int MIPSDecoder::FormatRegister(Instr* instr, const char* format) {
   ASSERT(format[0] == 'r');
   switch (format[1]) {
     case 's': {  // 'rs: Rs register
       PrintRegister(instr->RsField());
       return 2;
     }
     case 't': {  // 'rt: Rt register
       PrintRegister(instr->RtField());
       return 2;
     }
     case 'd': {  // 'rd: Rd register
       PrintRegister(instr->RdField());
       return 2;
     }
   }
   UNREACHABLE();
   return -1;
 }
 
 
+int MIPSDecoder::FormatFRegister(Instr* instr, const char* format) {
+  ASSERT(format[0] == 'f');
+  switch (format[1]) {
+    case 's': {  // 'fs: Fs register
+      PrintFRegister(instr->FsField());
+      return 2;
+    }
+    case 't': {  // 'ft: Ft register
+      PrintFRegister(instr->FtField());
+      return 2;
+    }
+    case 'd': {  // 'fd: Fd register
+      PrintFRegister(instr->FdField());
+      return 2;
+    }
+  }
+  UNREACHABLE();
+  return -1;
+}
+
+
+void MIPSDecoder::PrintFormat(Instr *instr) {
+  switch (instr->FormatField()) {
+    case FMT_S: {
+      Print("s");
+      break;
+    }
+    case FMT_D: {
+      Print("d");
+      break;
+    }
+    case FMT_W: {
+      Print("w");
+      break;
+    }
+    case FMT_L: {
+      Print("l");
+      break;
+    }
+    case FMT_PS: {
+      Print("ps");
+      break;
+    }
+    default: {
+      Print("unknown");
+      break;
+    }
+  }
+}
+
+
 // 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(),
@@ skipping 41 matching lines @@
         buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
                                    remaining_size_in_buffer(),
                                    "%d",
                                    imm);
       }
       return 4;
     }
     case 'r': {
       return FormatRegister(instr, format);
     }
+    case 'f': {
+      if (format[1] == 'm') {
+        ASSERT(STRING_STARTS_WITH(format, "fmt"));
+        PrintFormat(instr);
+        return 3;
+      } else {
+        return FormatFRegister(instr, format);
+      }
+    }
     case 's': {
       ASSERT(STRING_STARTS_WITH(format, "sa"));
       buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
                                  remaining_size_in_buffer(),
                                  "%d",
                                  instr->SaField());
       return 2;
     }
     default: {
       UNREACHABLE();
@@ skipping 207 matching lines @@
       Format(instr, "bltzl 'rs, 'dest");
       break;
     }
     default: {
       Unknown(instr);
       break;
     }
   }
 }
 
+void MIPSDecoder::DecodeCop1(Instr* instr) {
+  ASSERT(instr->OpcodeField() == COP1);
+  if (instr->HasFormat()) {
+    // If the rs field is a valid format, then the function field identifies
+    // the instruction.
+    switch (instr->Cop1FunctionField()) {
+      case COP1_ADD: {
+        Format(instr, "add.'fmt 'fd, 'fs, 'ft");
+        break;
+      }
+      case COP1_MOV: {
+        Format(instr, "mov.'fmt 'fd, 'fs");
+        break;
+      }
+      default: {
+        Unknown(instr);
+        break;
+      }
+    }
+  } else {
+    // If the rs field isn't a valid format, then it must be a sub-opcode.
+    switch (instr->Cop1SubField()) {
+      case COP1_MF: {
+        if (instr->Bits(0, 11) != 0) {
+          Unknown(instr);
+        } else {
+          Format(instr, "mfc1 'rt, 'fs");
+        }
+        break;
+      }
+      case COP1_MT: {
+        if (instr->Bits(0, 11) != 0) {
+          Unknown(instr);
+        } else {
+          Format(instr, "mtc1 'rt, 'fs");
+        }
+        break;
+      }
+      default: {
+        Unknown(instr);
+        break;
+      }
+    }
+  }
+}
 
 void MIPSDecoder::InstructionDecode(Instr* instr) {
   switch (instr->OpcodeField()) {
     case SPECIAL: {
       DecodeSpecial(instr);
       break;
     }
     case SPECIAL2: {
       DecodeSpecial2(instr);
       break;
     }
     case REGIMM: {
       DecodeRegImm(instr);
       break;
     }
+    case COP1: {
+      DecodeCop1(instr);
+      break;
+    }
     case ADDIU: {
       Format(instr, "addiu 'rt, 'rs, 'imms");
       break;
     }
     case ANDI: {
       Format(instr, "andi 'rt, 'rs, 'immu");
       break;
     }
     case BEQ: {
       Format(instr, "beq 'rs, 'rt, 'dest");
@@ skipping 28 matching lines @@
       break;
     }
     case LB: {
       Format(instr, "lb 'rt, 'imms('rs)");
       break;
     }
     case LBU: {
       Format(instr, "lbu 'rt, 'imms('rs)");
       break;
     }
+    case LDC1: {
+      Format(instr, "ldc1 'ft, 'imms('rs)");
+      break;
+    }
     case LH: {
       Format(instr, "lh 'rt, 'imms('rs)");
       break;
     }
     case LUI: {
       Format(instr, "lui 'rt, 'immu");
       break;
     }
     case LW: {
       Format(instr, "lw 'rt, 'imms('rs)");
       break;
     }
+    case LWC1: {
+      Format(instr, "lwc1 'ft, 'imms('rs)");
+      break;
+    }
     case ORI: {
       Format(instr, "ori 'rt, 'rs, 'immu");
       break;
     }
     case SB: {
       Format(instr, "sb 'rt, 'imms('rs)");
       break;
     }
     case SH: {
       Format(instr, "sh 'rt, 'imms('rs)");
       break;
     }
+    case SDC1: {
+      Format(instr, "sdc1 'ft, 'imms('rs)");
+      break;
+    }
     case SW: {
       Format(instr, "sw 'rt, 'imms('rs)");
       break;
     }
+    case SWC1: {
+      Format(instr, "swc1 'ft, 'imms('rs)");
+      break;
+    }
     default: {
       Unknown(instr);
       break;
     }
   }
 }
 
 
 void Disassembler::DecodeInstruction(char* hex_buffer, intptr_t hex_size,
                                      char* human_buffer, intptr_t human_size,
@@ skipping 38 matching lines @@
                                   pc);
     pc += instruction_length;
   }
 
   return;
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_MIPS