Begins implementation of ARM neon instructions.

runtime/vm/disassembler_arm.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_ARM.
 #if defined(TARGET_ARCH_ARM)
 #include "platform/assert.h"
 
@@ skipping 15 matching lines @@
   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);
   void PrintSRegister(int reg);
   void PrintDRegister(int reg);
+  void PrintQRegister(int reg);
   void PrintCondition(Instr* instr);
   void PrintShiftRm(Instr* instr);
   void PrintShiftImm(Instr* instr);
   void PrintPU(Instr* instr);
 
   // Handle formatting of instructions and their options.
   int FormatRegister(Instr* instr, const char* option);
   int FormatSRegister(Instr* instr, const char* option);
   int FormatDRegister(Instr* instr, const char* option);
+  int FormatQRegister(Instr* instr, const char* option);
   int FormatOption(Instr* instr, const char* option);
   void Format(Instr* instr, const char* format);
   void Unknown(Instr* instr);
 
   // Each of these functions decodes one particular instruction type, a 3-bit
   // field in the instruction encoding.
   // Types 0 and 1 are combined as they are largely the same except for the way
   // they interpret the shifter operand.
   void DecodeType01(Instr* instr);
   void DecodeType2(Instr* instr);
   void DecodeType3(Instr* instr);
   void DecodeType4(Instr* instr);
   void DecodeType5(Instr* instr);
   void DecodeType6(Instr* instr);
   void DecodeType7(Instr* instr);
+  void DecodeSIMDDataProcessing(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 60 matching lines @@
 
 void ARMDecoder::PrintDRegister(int reg) {
   ASSERT(0 <= reg);
   ASSERT(reg < kNumberOfDRegisters);
   buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
                              remaining_size_in_buffer(),
                              "d%d", reg);
 }
 
 
+void ARMDecoder::PrintQRegister(int reg) {
+  ASSERT(0 <= reg);
+  ASSERT(reg < kNumberOfQRegisters);
+  buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
+                             remaining_size_in_buffer(),
+                             "q%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"
 };
 
 
 // Print the register shift operands for the instruction. Generally used for
 // data processing instructions.
 void ARMDecoder::PrintShiftRm(Instr* instr) {
@@ skipping 194 matching lines @@
       }
     }
     Print("}");
     return 5;
   }
   UNREACHABLE();
   return -1;
 }
 
 
+int ARMDecoder::FormatQRegister(Instr* instr, const char* format) {
+  ASSERT(format[0] == 'q');
+  if (format[1] == 'n') {  // 'qn: Qn register
+    int reg = instr->QnField();
+    PrintQRegister(reg);
+    return 2;
+  } else if (format[1] == 'd') {  // 'qd: Qd register
+    int reg = instr->QdField();
+    PrintQRegister(reg);
+    return 2;
+  } else if (format[1] == 'm') {  // 'qm: Qm register
+    int reg = instr->QmField();
+    PrintQRegister(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 ARMDecoder::FormatOption(Instr* instr, const char* format) {
   switch (format[0]) {
     case 'a': {  // 'a: accumulate multiplies
       if (instr->Bit(21) == 0) {
         Print("ul");
@@ skipping 20 matching lines @@
         uword destination = reinterpret_cast<uword>(instr) + off;
         buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
                                    remaining_size_in_buffer(),
                                    "%#"Px"",
                                    destination);
         return 4;
       } else {
         return FormatDRegister(instr, format);
       }
     }
+    case 'q': {
+      return FormatQRegister(instr, format);
+    }
     case 'i': {  // 'imm12_4, imm4_12, immf, or immd
       uint16_t immed16;
       if (format[3] == 'f') {
         ASSERT(STRING_STARTS_WITH(format, "immf"));
         buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
                                    remaining_size_in_buffer(),
                                    "%f",
                                    instr->ImmFloatField());
         return 4;
       } else if (format[3] == 'd') {
@@ skipping 35 matching lines @@
     }
     case 'o': {
       if (format[3] == '1') {
         if (format[4] == '0') {
           // 'off10: 10-bit offset for VFP load and store instructions
           buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
                                      remaining_size_in_buffer(),
                                      "%d",
                                      instr->Bits(0, 8) << 2);
         } else {
-          // 'off12: 12-bit offset for load and store instructions
+          // 'off12: 12-bit offset for load and store instructions.
           ASSERT(STRING_STARTS_WITH(format, "off12"));
           buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
                                      remaining_size_in_buffer(),
                                      "%d",
                                      instr->Offset12Field());
         }
         return 5;
       }
-      // 'off8: 8-bit offset for extra load and store instructions
+      // 'off8: 8-bit offset for extra load and store instructions.
       ASSERT(STRING_STARTS_WITH(format, "off8"));
       int offs8 = (instr->ImmedHField() << 4) | instr->ImmedLField();
       buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
                                  remaining_size_in_buffer(),
                                  "%d",
                                  offs8);
       return 4;
     }
-    case 'p': {  // 'pu: P and U bits for load and store instructions
+    case 'p': {  // 'pu: P and U bits for load and store instructions.
       ASSERT(STRING_STARTS_WITH(format, "pu"));
       PrintPU(instr);
       return 2;
     }
     case 'r': {
       return FormatRegister(instr, format);
     }
     case 's': {
       if (format[1] == 'h') {  // 'shift_op or 'shift_rm
         if (format[6] == 'o') {  // 'shift_op
@@ skipping 10 matching lines @@
           PrintShiftRm(instr);
           return 8;
         }
       } else if (format[1] == 'v') {  // 'svc
         ASSERT(STRING_STARTS_WITH(format, "svc"));
         buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
                                    remaining_size_in_buffer(),
                                    "0x%x",
                                    instr->SvcField());
         return 3;
+      } else if (format[1] == 'z') {
+        // 'sz: Size field of SIMD instruction.
+        int sz = 8 << (instr->Bits(20, 2));
+        buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
+                                   remaining_size_in_buffer(),
+                                   "I%d",
+                                   sz);
+        return 2;
       } else if (format[1] == ' ') {
-        // 's: S field of data processing instructions
+        // 's: S field of data processing instructions.
         if (instr->HasS()) {
           Print("s");
         }
         return 1;
       } else {
         return FormatSRegister(instr, format);
       }
     }
-    case 't': {  // 'target: target of branch instructions
+    case 't': {  // 'target: target of branch instructions.
       ASSERT(STRING_STARTS_WITH(format, "target"));
       int off = (instr->SImmed24Field() << 2) + 8;
       buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
                                  remaining_size_in_buffer(),
                                  "%+d",
                                  off);
       return 6;
     }
-    case 'u': {  // 'u: signed or unsigned multiplies
+    case 'u': {  // 'u: signed or unsigned multiplies.
       if (instr->Bit(22) == 0) {
         Print("u");
       } else {
         Print("s");
       }
       return 1;
     }
-    case 'w': {  // 'w: W field of load and store instructions
+    case 'w': {  // 'w: W field of load and store instructions.
       if (instr->HasW()) {
         Print("!");
       }
       return 1;
     }
-    case 'x': {  // 'x: type of extra load/store instructions
+    case 'x': {  // 'x: type of extra load/store instructions.
       if (!instr->HasSign()) {
         Print("h");
       } else if (instr->HasL()) {
         if (instr->HasH()) {
           Print("sh");
         } else {
           Print("sb");
         }
       } else {
         Print("d");
@@ skipping 674 matching lines @@
       } else {
         Unknown(instr);
       }
     }
   } else {
     Unknown(instr);
   }
 }
 
 
+void ARMDecoder::DecodeSIMDDataProcessing(Instr* instr) {
+  ASSERT(instr->ConditionField() == kSpecialCondition);
+  if (instr->Bit(6) == 1) {
+    if ((instr->Bits(8, 4) == 8) && (instr->Bit(4) == 0) &&
+        (instr->Bit(24) == 0)) {
+      Format(instr, "vadd.'sz 'qd, 'qn, 'qm");
+    } else if ((instr->Bits(8, 4) == 13) && (instr->Bit(4) == 0) &&
+        (instr->Bit(24) == 0)) {
+      Format(instr, "vadd.F32 'qd, 'qn, 'qm");
+    } else {
+      Unknown(instr);
+    }
+  } else {
+    Unknown(instr);
+  }
+}
+
+
 void ARMDecoder::InstructionDecode(uword pc) {
   Instr* instr = Instr::At(pc);
 
   if (instr->ConditionField() == kSpecialCondition) {
     if (instr->InstructionBits() == static_cast<int32_t>(0xf57ff01f)) {
       Format(instr, "clrex");
     } else {
-      Unknown(instr);
+      if (instr->IsSIMDDataProcessing()) {
+        DecodeSIMDDataProcessing(instr);
+      } else {
+        Unknown(instr);
+      }
     }
   } else {
     switch (instr->TypeField()) {
       case 0:
       case 1: {
         DecodeType01(instr);
         break;
       }
       case 2: {
         DecodeType2(instr);
@@ skipping 70 matching lines @@
                                   human_buffer,
                                   sizeof(human_buffer),
                                   pc);
     pc += instruction_length;
   }
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM