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

src/arm/macro-assembler-arm.h

Index: src/arm/macro-assembler-arm.h
diff --git a/src/arm/macro-assembler-arm.h b/src/arm/macro-assembler-arm.h
index 8b9fa2b22162bf0e1b1e1d8343bb3ebd1771fa10..431f01249e2e0422091b295e6ca8755a81d80145 100644
--- a/src/arm/macro-assembler-arm.h
+++ b/src/arm/macro-assembler-arm.h
@@ -86,6 +86,34 @@ class MacroAssembler: public Assembler {
   // 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);
@@ -461,8 +489,13 @@ class MacroAssembler: public Assembler {
   void VFPEnsureFPSCRState(Register scratch);
 
   // If the value is a NaN, canonicalize the value else, do nothing.
-  void VFPCanonicalizeNaN(const DwVfpRegister value,
+  void VFPCanonicalizeNaN(const DwVfpRegister result,
+                          const DwVfpRegister value,
                           const Condition cond = al);
+  void VFPCanonicalizeNaN(const DwVfpRegister value,
+                          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,
@@ -842,11 +875,20 @@ class MacroAssembler: public Assembler {
   // 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.