[v8-dev] ARM: Improve Lithium register constraints.

src/arm/macro-assembler-arm.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // 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
@@ skipping 68 matching lines @@
 
 // MacroAssembler implements a collection of frequently used macros.
 class MacroAssembler: public Assembler {
  public:
   // The isolate parameter can be NULL if the macro assembler should
   // not use isolate-dependent functionality. In this case, it's the
   // responsibility of the caller to never invoke such function on the
   // macro assembler.
   MacroAssembler(Isolate* isolate, void* buffer, int size);
 
+  // Helper instructions using the macro assembler temporary register (ip) to
+  // perform their task. If the MemOperand is used used more than once then it
+  // is more efficient to load it separately.
+  void AddMemOperand(Register dst,
+                     Register src1,
+                     const MemOperand& src2,
+                     SBit s = LeaveCC);
+  void SubMemOperand(Register dst,
+                     Register src1,
+                     const MemOperand& src2,
+                     SBit s = LeaveCC);
+  void RsbMemOperand(Register dst,
+                     Register src1,
+                     const MemOperand& src2,
+                     SBit s = LeaveCC);
+  void AndMemOperand(Register dst,
+                     Register src1,
+                     const MemOperand& src2,
+                     SBit s = LeaveCC);
+  void OrrMemOperand(Register dst,
+                     Register src1,
+                     const MemOperand& src2,
+                     SBit s = LeaveCC);
+  void EorMemOperand(Register dst,
+                     Register src1,
+                     const MemOperand& src2,
+                     SBit s = LeaveCC);
+
   // Jump, Call, and Ret pseudo instructions implementing inter-working.
   void Jump(Register target, Condition cond = al);
   void Jump(Address target, RelocInfo::Mode rmode, Condition cond = al);
   void Jump(Handle<Code> code, RelocInfo::Mode rmode, Condition cond = al);
   static int CallSize(Register target, Condition cond = al);
   void Call(Register target, Condition cond = al);
   int CallSize(Address target, RelocInfo::Mode rmode, Condition cond = al);
   static int CallSizeNotPredictableCodeSize(Address target,
                                             RelocInfo::Mode rmode,
                                             Condition cond = al);
@@ skipping 355 matching lines @@
   // Ensure that FPSCR contains values needed by JavaScript.
   // We need the NaNModeControlBit to be sure that operations like
   // vadd and vsub generate the Canonical NaN (if a NaN must be generated).
   // In VFP3 it will be always the Canonical NaN.
   // In VFP2 it will be either the Canonical NaN or the negative version
   // of the Canonical NaN. It doesn't matter if we have two values. The aim
   // is to be sure to never generate the hole NaN.
   void VFPEnsureFPSCRState(Register scratch);
 
   // If the value is a NaN, canonicalize the value else, do nothing.
+  void VFPCanonicalizeNaN(const DwVfpRegister result,
+                          const DwVfpRegister value,
+                          const Condition cond = al);
   void VFPCanonicalizeNaN(const DwVfpRegister value,
-                          const Condition cond = al);
+                          const Condition cond = al) {
+    VFPCanonicalizeNaN(value, value, cond);
+  }
 
   // Compare double values and move the result to the normal condition flags.
   void VFPCompareAndSetFlags(const DwVfpRegister src1,
                              const DwVfpRegister src2,
                              const Condition cond = al);
   void VFPCompareAndSetFlags(const DwVfpRegister src1,
                              const double src2,
                              const Condition cond = al);
 
   // Compare double values and then load the fpscr flags to a register.
@@ skipping 359 matching lines @@
                                Label* miss,
                                bool miss_on_bound_function = false);
 
   // Compare object type for heap object.  heap_object contains a non-Smi
   // whose object type should be compared with the given type.  This both
   // sets the flags and leaves the object type in the type_reg register.
   // It leaves the map in the map register (unless the type_reg and map register
   // are the same register).  It leaves the heap object in the heap_object
   // register unless the heap_object register is the same register as one of the
   // other registers.
+  // Type_reg can be no_reg. In that case ip is used.
   void CompareObjectType(Register heap_object,
                          Register map,
                          Register type_reg,
                          InstanceType type);
 
+  // Compare object type for heap object. Branch to false_label if type
+  // is lower than min_type or greater than max_type.
+  void CheckObjectTypeRange(Register heap_object,
+                              Register map,
+                              InstanceType min_type,
+                              InstanceType max_type,
+                              Label* false_label);
+
   // Compare instance type in a map.  map contains a valid map object whose
   // object type should be compared with the given type.  This both
   // sets the flags and leaves the object type in the type_reg register.
   void CompareInstanceType(Register map,
                            Register type_reg,
                            InstanceType type);
 
 
   // Check if a map for a JSObject indicates that the object has fast elements.
   // Jump to the specified label if it does not.
@@ skipping 598 matching lines @@
 #define __FILE_LINE__ __FILE__ ":" CODE_COVERAGE_TOSTRING(__LINE__)
 #define ACCESS_MASM(masm) masm->stop(__FILE_LINE__); masm->
 #else
 #define ACCESS_MASM(masm) masm->
 #endif
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_ARM_MACRO_ASSEMBLER_ARM_H_