ARM: Add support load/store multiple VFP registers

src/arm/disasm-arm.cc

 // Copyright 2010 the V8 project authors. All rights reserved.

[Karl Klose, 2011/04/06 06:52:56]

2011

[Søren Thygesen Gjesse, 2011/04/06 08:00:09]

Done.

 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
 //       with the distribution.
@@ skipping 364 matching lines @@
     if (format[0] == 'S') PrintSRegister(((reg << 1) | instr->NValue()));
     if (format[0] == 'D') PrintDRegister(reg);
     return 2;
   } else if (format[1] == 'm') {
     int reg = instr->VmValue();
     if (format[0] == 'S') PrintSRegister(((reg << 1) | instr->MValue()));
     if (format[0] == 'D') PrintDRegister(reg);
     return 2;
   } else if (format[1] == 'd') {
     int reg = instr->VdValue();
-    if (format[0] == 'S') PrintSRegister(((reg << 1) | instr->DValue()));
+    if (format[0] == 'S') reg = reg << 1 | instr->DValue();

[Rodolph Perfetta, 2011/04/05 18:16:39]

Using instr->VFPDRegValue(kSinglePrecision) would simplify the code. Could also
be reused above.

[Søren Thygesen Gjesse, 2011/04/06 08:00:09]

Changed to use instr->VFPXRegValue (X=M|M|D) in all cases and refactored a bit.

+    if (format[2] == '+') {
+      int immed8 = instr->Immed8Value();
+      if (format[0] == 'S') reg += immed8 - 1;
+      if (format[0] == 'D') reg += (immed8 / 2 - 1);
+    }
+    if (format[0] == 'S') PrintSRegister(reg);
     if (format[0] == 'D') PrintDRegister(reg);
-    return 2;
+    return format[2] == '+' ? 3 : 2;
   }
 
   UNREACHABLE();
   return -1;
 }
 
 
 int Decoder::FormatVFPinstruction(Instruction* instr, const char* format) {
     Print(format);
     return 0;
@@ skipping 867 matching lines @@
         }
         break;
       case 0xC:
       case 0xE:
         if (instr->HasL()) {
           Format(instr, "vldr'cond 'Sd, ['rn + 4*'imm08@00]");
         } else {
           Format(instr, "vstr'cond 'Sd, ['rn + 4*'imm08@00]");
         }
         break;
-      default:
-        Unknown(instr);  // Not used by V8.
+      default: {

[Rodolph Perfetta, 2011/04/05 18:16:39]

VLDM/VSTM covers cases 0x4-0x7, 0x9, 0xB for single precision. Some cases are
undefined instructions (P==U, W==0)

[Søren Thygesen Gjesse, 2011/04/06 08:00:09]

Changed to use 6 explicit case values and default as before.

+        BlockAddrMode am =
+            static_cast<BlockAddrMode>(
+                instr->BitField(24, 21) & kBlockAddrModeMask);
+        if (am == ia || am == ia_w || am == db_w) {
+          bool to_arm_register = (instr->VLValue() == 0x1);

[Rodolph Perfetta, 2011/04/05 18:16:39]

This variable has a confusing name. It sounds like you're using vldm to load
into an ARM (rather than VFP) register.

[Søren Thygesen Gjesse, 2011/04/06 08:00:09]

Changed to to_vfp_regsiter.

+          if (to_arm_register) {
+            Format(instr, "vldm'cond'pu 'rn'w, {'Sd-'Sd+}");
+          } else {
+            Format(instr, "vstm'cond'pu 'rn'w, {'Sd-'Sd+}");
+          }
+        } else {
+          Unknown(instr);  // Not used by V8.
+        }
         break;
+      }
     }
   } else if (instr->CoprocessorValue() == 0xB) {
     switch (instr->OpcodeValue()) {
       case 0x2:
         // Load and store double to two GP registers
         if (instr->Bits(7, 4) != 0x1) {
           Unknown(instr);  // Not used by V8.
         } else if (instr->HasL()) {
           Format(instr, "vmov'cond 'rt, 'rn, 'Dm");
         } else {
           Format(instr, "vmov'cond 'Dm, 'rt, 'rn");
         }
         break;
       case 0x8:
         if (instr->HasL()) {
           Format(instr, "vldr'cond 'Dd, ['rn - 4*'imm08@00]");
         } else {
           Format(instr, "vstr'cond 'Dd, ['rn - 4*'imm08@00]");
         }
         break;
       case 0xC:
         if (instr->HasL()) {
           Format(instr, "vldr'cond 'Dd, ['rn + 4*'imm08@00]");
         } else {
           Format(instr, "vstr'cond 'Dd, ['rn + 4*'imm08@00]");
         }
         break;
-      default:
-        Unknown(instr);  // Not used by V8.
+      default: {

[Rodolph Perfetta, 2011/04/05 18:16:39]

VLDM/VSTM covers cases 0x4, 0x5, 0x9 for double precision in V8. The difference
between single and double precision cases is caused by V8 supporting 16
D-registers (removing cases 0x6, 0x7, 0xB.)

[Søren Thygesen Gjesse, 2011/04/06 08:00:09]

Changed to use 3 explicit case values and default as before.

+        BlockAddrMode am =
+            static_cast<BlockAddrMode>(
+                instr->BitField(24, 21) & kBlockAddrModeMask);
+        if (am == ia || am == ia_w || am == db_w) {
+          bool to_arm_register = (instr->VLValue() == 0x1);
+          if (to_arm_register) {
+            Format(instr, "vldm'cond'pu 'rn'w, {'Dd-'Dd+}");
+          } else {
+            Format(instr, "vstm'cond'pu 'rn'w, {'Dd-'Dd+}");
+          }
+        } else {
+          Unknown(instr);  // Not used by V8.
+        }
         break;
+      }
     }
   } else {
     Unknown(instr);  // Not used by V8.
   }
 }
 
 
 bool Decoder::IsConstantPoolAt(byte* instr_ptr) {
   int instruction_bits = *(reinterpret_cast<int*>(instr_ptr));
   return (instruction_bits & kConstantPoolMarkerMask) == kConstantPoolMarker;
@@ skipping 143 matching lines @@
     pc += d.InstructionDecode(buffer, pc);
     fprintf(f, "%p    %08x      %s\n",
             prev_pc, *reinterpret_cast<int32_t*>(prev_pc), buffer.start());
   }
 }
 
 
 }  // namespace disasm
 
 #endif  // V8_TARGET_ARCH_ARM