Adds ldp and stp instructions to ARM64.

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 16 matching lines @@
 
  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 PrintPairMemOperand(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);
 
@@ skipping 162 matching lines @@
     }
     Print("]");
   } else {
     switch (instr->Bits(10, 2)) {
       case 0: {
         // rn + signed 9-bit immediate, pre-index, no writeback.
         const int32_t imm9 = instr->SImm9Field();
         Print("[");
         PrintRegister(rn, R31IsSP);
         buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
-                           remaining_size_in_buffer(),
-                           ", #%d",
-                           imm9);
+                                   remaining_size_in_buffer(),
+                                   ", #%d",
+                                   imm9);
         Print("]");
         break;
       }
       case 1: {
         const int32_t imm9 = instr->SImm9Field();
         // rn + signed 9-bit immediate, post-index, writeback.
         Print("[");
         PrintRegister(rn, R31IsSP);
         Print("]");
         buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
@@ skipping 33 matching lines @@
         break;
       }
       default: {
         Print("???");
       }
     }
   }
 }
 
 
+void ARM64Decoder::PrintPairMemOperand(Instr* instr) {
+  const Register rn = instr->RnField();
+  const int32_t simm7 = instr->SImm7Field();
+  const int32_t offset = simm7 << (2 + instr->Bit(31));
+  Print("[");
+  PrintRegister(rn, R31IsSP);
+  switch (instr->Bits(23, 3)) {
+    case 1:
+      // rn + (imm7 << (2 + B31)), post-index, writeback.
+      buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
+                                 remaining_size_in_buffer(),
+                                 "], #%d !",
+                                 offset);
+      break;
+    case 2:
+      // rn + (imm7 << (2 + B31)), pre-index, no writeback.
+      buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
+                                 remaining_size_in_buffer(),
+                                 ", #%d ]",
+                                 offset);
+      break;
+    case 3:
+      // rn + (imm7 << (2 + B31)), pre-index, writeback.
+      buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
+                                 remaining_size_in_buffer(),
+                                 ", #%d ]!",
+                                 offset);
+      break;
+    default:
+      Print(", ???]");
+      break;
+  }
+}
+
+
 // Handle all register based formatting in these functions to reduce the
 // complexity of FormatOption.
 int ARM64Decoder::FormatRegister(Instr* instr, const char* format) {
   ASSERT(format[0] == 'r');
   if (format[1] == 'n') {  // 'rn: Rn register
     int reg = instr->RnField();
     PrintRegister(reg, instr->RnMode());
     return 2;
   } else if (format[1] == 'd') {  // 'rd: Rd register
     int reg = instr->RdField();
@@ skipping 219 matching lines @@
                                    dimm);
         return 4;
       }
     }
     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();
-        const int64_t immlo = instr->Bits(29, 2);
-        const int64_t off = (immhi << 2) | immlo;
-        const int64_t pc = reinterpret_cast<int64_t>(instr);
-        const int64_t dest = pc + off;
-        buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
-                                   remaining_size_in_buffer(),
-                                   "0x%"Px64,
-                                   dest);
+      if (format[1] == 'c') {
+        if (format[2] == 'a') {
+          ASSERT(STRING_STARTS_WITH(format, "pcadr"));
+          const int64_t immhi = instr->SImm19Field();
+          const int64_t immlo = instr->Bits(29, 2);
+          const int64_t off = (immhi << 2) | immlo;
+          const int64_t pc = reinterpret_cast<int64_t>(instr);
+          const int64_t dest = pc + off;
+          buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
+                                     remaining_size_in_buffer(),
+                                     "0x%"Px64,
+                                     dest);
+        } else {
+          ASSERT(STRING_STARTS_WITH(format, "pcldr"));
+          const int64_t off = instr->SImm19Field() << 2;
+          const int64_t pc = reinterpret_cast<int64_t>(instr);
+          const int64_t dest = pc + off;
+          buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
+                                     remaining_size_in_buffer(),
+                                     "0x%"Px64,
+                                     dest);
+        }
+        return 5;
       } else {
-        ASSERT(STRING_STARTS_WITH(format, "pcldr"));
-        const int64_t off = instr->SImm19Field() << 2;
-        const int64_t pc = reinterpret_cast<int64_t>(instr);
-        const int64_t dest = pc + off;
-        buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
-                                   remaining_size_in_buffer(),
-                                   "0x%"Px64,
-                                   dest);
+        ASSERT(STRING_STARTS_WITH(format, "pmemop"));
+        PrintPairMemOperand(instr);
+        return 6;
       }
-      return 5;
     }
     case 'r': {
       return FormatRegister(instr, format);
     }
     case 'v': {
       if (format[1] == 's') {
         ASSERT(STRING_STARTS_WITH(format, "vsz"));
         char const* sz_str = NULL;
         if (instr->Bits(14, 2) == 3) {
           switch (instr->Bit(22)) {
@@ skipping 121 matching lines @@
     // Integer src/dst.
     if (instr->Bits(22, 2) == 0) {
       Format(instr, "str'sz 'rt, 'memop");
     } else {
       Format(instr, "ldr'sz 'rt, 'memop");
     }
   }
 }
 
 
+void ARM64Decoder::DecodeLoadStoreRegPair(Instr* instr) {
+  if (instr->Bit(22) == 1) {
+    // Load.
+    Format(instr, "ldp'sf 'rt, 'ra, 'pmemop");
+  } else {
+    // Store.
+    Format(instr, "stp'sf 'rt, 'ra, 'pmemop");
+  }
+}
+
+
 void ARM64Decoder::DecodeLoadRegLiteral(Instr* instr) {
   if ((instr->Bit(31) != 0) || (instr->Bit(29) != 0) ||
       (instr->Bits(24, 3) != 0)) {
     Unknown(instr);
   }
   if (instr->Bit(30)) {
     Format(instr, "ldrx 'rt, 'pcldr");
   } else {
     Format(instr, "ldrw 'rt, 'pcldr");
   }
@@ skipping 187 matching lines @@
     DecodeUnconditionalBranch(instr);
   } else {
     Unknown(instr);
   }
 }
 
 
 void ARM64Decoder::DecodeLoadStore(Instr* instr) {
   if (instr->IsLoadStoreRegOp()) {
     DecodeLoadStoreReg(instr);
+  } else if (instr->IsLoadStoreRegPairOp()) {
+    DecodeLoadStoreRegPair(instr);
   } else if (instr->IsLoadRegLiteralOp()) {
     DecodeLoadRegLiteral(instr);
   } else {
     Unknown(instr);
   }
 }
 
 
 void ARM64Decoder::DecodeAddSubShiftExt(Instr* instr) {
   switch (instr->Bit(30)) {
@@ skipping 492 matching lines @@
                                   human_buffer,
                                   sizeof(human_buffer),
                                   pc);
     pc += instruction_length;
   }
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM