Add vrint{a,n,p,m,z} instructions to arm assembler.

src/arm/disasm-arm.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // A Disassembler object is used to disassemble a block of code instruction by
 // instruction. The default implementation of the NameConverter object can be
 // overriden to modify register names or to do symbol lookup on addresses.
 //
 // The example below will disassemble a block of code and print it to stdout.
 //
@@ skipping 1259 matching lines @@
                  (instr->Opc3Value() & 0x1)) {
         DecodeVCMP(instr);
       } else if (((instr->Opc2Value() == 0x1)) && (instr->Opc3Value() == 0x3)) {
         Format(instr, "vsqrt'cond.f64 'Dd, 'Dm");
       } else if (instr->Opc3Value() == 0x0) {
         if (instr->SzValue() == 0x1) {
           Format(instr, "vmov'cond.f64 'Dd, 'd");
         } else {
           Unknown(instr);  // Not used by V8.
         }
+      } else if (((instr->Opc2Value() == 0x6)) && (instr->Opc3Value() & 0x1)) {
+        bool dp_operation = (instr->SzValue() == 1);
+        if (instr->Opc3Value() & 0x2) {
+          // vrintz - round towards zero (truncate)
+          if (dp_operation) {
+            Format(instr, "vrintz'cond.f64.f64 'Dd, 'Dm");
+          } else {
+            Format(instr, "vrintz'cond.f32.f32 'Sd, 'Sm");
+          }
+        } else {
+          // vrintr - round according to rounding mode in FPSCR

[Rodolph Perfetta (ARM), 2014/10/28 19:41:41]

vrintr is not implemented by this patch, usually the disassembler only provide
support for what V8 generates (and test). So how about calling Unknown(instr);
here.

[sigurds, 2014/10/29 11:47:15]

Done.

+          if (dp_operation) {
+            Format(instr, "vrintr'cond.f64.f64 'Dd, 'Dm");
+          } else {
+            Format(instr, "vrintr'cond.f32.f32 'Sd, 'Sm");
+          }
+        }
       } else {
         Unknown(instr);  // Not used by V8.
       }
     } else if (instr->Opc1Value() == 0x3) {
       if (instr->SzValue() == 0x1) {
         if (instr->Opc3Value() & 0x1) {
           Format(instr, "vsub'cond.f64 'Dd, 'Dn, 'Dm");
         } else {
           Format(instr, "vadd'cond.f64 'Dd, 'Dn, 'Dm");
         }
@@ skipping 330 matching lines @@
           out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_,
                                       "pld [r%d, #-%d]", Rn, offset);
         } else {
           out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_,
                                       "pld [r%d, #+%d]", Rn, offset);
         }
       } else {
         Unknown(instr);
       }
       break;
+    case 0x1D:
+      if (instr->Opc1Value() == 0x7 && instr->Bits(19, 18) == 0x2 &&
+          instr->Bits(11, 9) == 0x5 && instr->Bits(7, 6) == 0x1 &&
+          instr->Bit(4) == 0x0) {
+        // VRINTA, VRINTN, VRINTP, VRINTM (floating-point)
+        bool dp_operation = (instr->SzValue() == 1);
+        int rounding_mode = instr->Bits(17, 16);
+        switch (rounding_mode) {
+          case 0x0:
+            if (dp_operation) {
+              Format(instr, "vrinta.f64.f64 'Dd, 'Dm");
+            } else {
+              Format(instr, "vrinta.f32.f32 'Sd, 'Sm");

[Rodolph Perfetta (ARM), 2014/10/28 19:41:41]

You don't implement single precision, so I would handle them as unknown
instructions.

Same apply for vrintn/p/m below.

[sigurds, 2014/10/29 11:47:15]

Done.

+            }
+            break;
+          case 0x1:
+            if (dp_operation) {
+              Format(instr, "vrintn.f64.f64 'Dd, 'Dm");
+            } else {
+              Format(instr, "vrintn.f32.f32 'Sd, 'Sm");
+            }
+            break;
+          case 0x2:
+            if (dp_operation) {
+              Format(instr, "vrintp.f64.f64 'Dd, 'Dm");
+            } else {
+              Format(instr, "vrintp.f32.f32 'Sd, 'Sm");
+            }
+            break;
+          case 0x3:
+            if (dp_operation) {
+              Format(instr, "vrintm.f64.f64 'Dd, 'Dm");
+            } else {
+              Format(instr, "vrintm.f32.f32 'Sd, 'Sm");
+            }
+            break;
+          default:
+            UNREACHABLE();  // Case analysis is exhaustive.
+            break;
+        }
+      } else {
+        Unknown(instr);
+      }
+      break;
     default:
       Unknown(instr);
       break;
   }
 }
 
 #undef VERIFIY
 
 bool Decoder::IsConstantPoolAt(byte* instr_ptr) {
   int instruction_bits = *(reinterpret_cast<int*>(instr_ptr));
@@ skipping 152 matching lines @@
     v8::internal::PrintF(
         f, "%p    %08x      %s\n",
         prev_pc, *reinterpret_cast<int32_t*>(prev_pc), buffer.start());
   }
 }
 
 
 }  // namespace disasm
 
 #endif  // V8_TARGET_ARCH_ARM