Begins work on arm64 floating point instructions.

runtime/vm/disassembler_arm64.cc

 // Copyright (c) 2014, 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_ARM64.
 #if defined(TARGET_ARCH_ARM64)
 #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(uword pc);
 
  private:
   // Bottleneck functions to print into the out_buffer.
   void Print(const char* str);
 
   // Printing of common values.
   void PrintRegister(int reg, R31Type r31t);
+  void PrintVRegister(int reg);
   void PrintShiftExtendRm(Instr* instr);
   void PrintMemOperand(Instr* instr);
   void PrintS(Instr* instr);
   void PrintCondition(Instr* instr);
 
   // Handle formatting of instructions and their options.
   int FormatRegister(Instr* instr, const char* option);
+  int FormatVRegister(Instr*instr, const char* option);
   int FormatOption(Instr* instr, const char* format);
   void Format(Instr* instr, const char* format);
   void Unknown(Instr* instr);
 
   // Decode instructions.
   #define DECODE_OP(op)                                                        \
     void Decode##op(Instr* instr);
   APPLY_OP_LIST(DECODE_OP)
   #undef DECODE_OP
 
@@ skipping 45 matching lines @@
   ASSERT(reg < kNumberOfCpuRegisters);
   if (reg == 31) {
     const char* rstr = (r31t == R31IsZR) ? "zr" : "sp";
     Print(rstr);
   } else {
     Print(reg_names[reg]);
   }
 }
 
 
+void ARM64Decoder::PrintVRegister(int reg) {
+  ASSERT(0 <= reg);
+  ASSERT(reg < kNumberOfVRegisters);
+  buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
+                             remaining_size_in_buffer(),
+                             "v%d", reg);
+}
+
+
 // These shift names are defined in a way to match the native disassembler
 // formatting. See for example the command "objdump -d <binary file>".
 static const char* shift_names[kMaxShift] = {
   "lsl", "lsr", "asr", "ror"
 };
 
 
 static const char* extend_names[kMaxExtend] = {
   "uxtb", "uxth", "uxtw", "uxtx",
   "sxtb", "sxth", "sxtw", "sxtx",
@@ skipping 168 matching lines @@
   } else if (format[1] == 'a') {  // 'ra: Ra register
     int reg = instr->RaField();
     PrintRegister(reg, R31IsZR);
     return 2;
   }
   UNREACHABLE();
   return -1;
 }
 
 
+int ARM64Decoder::FormatVRegister(Instr* instr, const char* format) {
+  ASSERT(format[0] == 'v');
+  if (format[1] == 'd') {
+    int reg = instr->VdField();
+    PrintVRegister(reg);
+    return 2;
+  } else if (format[1] == 'n') {
+    int reg = instr->VnField();
+    PrintVRegister(reg);
+    return 2;
+  }
+  UNREACHABLE();
+  return -1;
+}
+
+
 // 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 ARM64Decoder::FormatOption(Instr* instr, const char* format) {
   switch (format[0]) {
     case 'b': {
       if (format[3] == 'i') {
         ASSERT(STRING_STARTS_WITH(format, "bitimm"));
@@ skipping 52 matching lines @@
       ASSERT(STRING_STARTS_WITH(format, "hw"));
       const int shift = instr->HWField() << 4;
       if (shift != 0) {
         buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
                                    remaining_size_in_buffer(),
                                    "lsl %d",
                                    shift);
       }
       return 2;
     }
-    case 'i': {  // 'imm12, imm16
-      uint64_t imm;
-      int ret = 5;
-      if (format[4] == '2') {
-        ASSERT(STRING_STARTS_WITH(format, "imm12"));
-        imm = instr->Imm12Field();
-        if (format[5] == 's') {
-          // shifted immediate.
-          if (instr->Imm12ShiftField() == 1) {
-            imm = imm << 12;
-          } else if ((instr->Imm12ShiftField() & 0x2) != 0) {
-            Print("Unknown Shift");
+    case 'i': {  // 'imm12, 'imm16, 'immd
+      if (format[3] == '1') {
+        uint64_t imm;
+        int ret = 5;
+        if (format[4] == '2') {
+          ASSERT(STRING_STARTS_WITH(format, "imm12"));
+          imm = instr->Imm12Field();
+          if (format[5] == 's') {
+            // shifted immediate.
+            if (instr->Imm12ShiftField() == 1) {
+              imm = imm << 12;
+            } else if ((instr->Imm12ShiftField() & 0x2) != 0) {
+              Print("Unknown Shift");
+            }
+            ret = 6;
           }
-          ret = 6;
+        } else {
+          ASSERT(STRING_STARTS_WITH(format, "imm16"));
+          imm = instr->Imm16Field();
         }
+        buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
+                                   remaining_size_in_buffer(),
+                                   "0x%"Px64,
+                                   imm);
+        return ret;
       } else {
-        ASSERT(STRING_STARTS_WITH(format, "imm16"));
-        imm = instr->Imm16Field();
+        ASSERT(STRING_STARTS_WITH(format, "immd"));
+        double dimm = bit_cast<double, int64_t>(
+            Instr::VFPExpandImm(instr->Imm8Field()));
+        buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
+                                   remaining_size_in_buffer(),
+                                   "%f",
+                                   dimm);
+        return 4;
       }
-      buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
-                                 remaining_size_in_buffer(),
-                                 "0x%"Px64,
-                                 imm);
-      return ret;
     }
     case 'm': {
       ASSERT(STRING_STARTS_WITH(format, "memop"));
       PrintMemOperand(instr);
       return 5;
     }
     case 'p': {
       if (format[2] == 'a') {
         ASSERT(STRING_STARTS_WITH(format, "pcadr"));
         const int64_t immhi = instr->SImm19Field();
@@ skipping 13 matching lines @@
         buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
                                    remaining_size_in_buffer(),
                                    "0x%"Px64,
                                    dest);
       }
       return 5;
     }
     case 'r': {
       return FormatRegister(instr, format);
     }
+    case 'v': {
+      return FormatVRegister(instr, format);
+    }
     case 's': {  // 's: S flag.
       if (format[1] == 'h') {
         ASSERT(STRING_STARTS_WITH(format, "shift_op"));
         PrintShiftExtendRm(instr);
         return 8;
       } else if (format[1] == 'f') {
         ASSERT(STRING_STARTS_WITH(format, "sf"));
         if (instr->SFField() == 1) {
           // TODO(zra): If we don't use the w form much, we can omit printing
           // this x.
@@ skipping 439 matching lines @@
     Unknown(instr);
   }
 }
 
 
 void ARM64Decoder::DecodeDPSimd1(Instr* instr) {
   Unknown(instr);
 }
 
 
+void ARM64Decoder::DecodeFPImm(Instr* instr) {
+  if ((instr->Bit(31) != 0) || (instr->Bit(29) != 0) || (instr->Bit(23) != 0) ||
+      (instr->Bits(5, 5) != 0)) {
+    Unknown(instr);
+    return;
+  }
+  if (instr->Bit(22) == 1) {
+    // Double.
+    Format(instr, "fmovd 'vd, 'immd");
+  } else {
+    // Single.
+    Unknown(instr);
+  }
+}
+
+
+void ARM64Decoder::DecodeFPIntCvt(Instr* instr) {
+  if ((instr->SFField() != 1) || (instr->Bit(29) != 0) ||
+      (instr->Bits(22, 2) != 1)) {
+    Unknown(instr);
+    return;
+  }
+  if (instr->Bits(16, 3) == 6) {
+    Format(instr, "fmovrd 'rd, 'vn");
+  } else if (instr->Bits(16, 3) == 7) {
+    Format(instr, "fmovdr 'vd, 'rn");
+  } else {
+    Unknown(instr);
+  }
+}
+
+
+void ARM64Decoder::DecodeFP(Instr* instr) {
+  if (instr->IsFPImmOp()) {
+    DecodeFPImm(instr);
+  } else if (instr->IsFPIntCvtOp()) {
+    DecodeFPIntCvt(instr);
+  } else {
+    Unknown(instr);
+  }
+}
+
+
 void ARM64Decoder::DecodeDPSimd2(Instr* instr) {
-  Unknown(instr);
+  if (instr->IsFPOp()) {
+    DecodeFP(instr);
+  } else {
+    Unknown(instr);
+  }
 }
 
 
 void ARM64Decoder::InstructionDecode(uword pc) {
   Instr* instr = Instr::At(pc);
 
   if (instr->IsDPImmediateOp()) {
     DecodeDPImmediate(instr);
   } else if (instr->IsCompareBranchOp()) {
     DecodeCompareBranch(instr);
@@ skipping 52 matching lines @@
                                   human_buffer,
                                   sizeof(human_buffer),
                                   pc);
     pc += instruction_length;
   }
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM