Use GPRs for mints

runtime/vm/locations.h

 // Copyright (c) 2013, 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.
 
 #ifndef VM_LOCATIONS_H_
 #define VM_LOCATIONS_H_
 
 #include "vm/allocation.h"
 #include "vm/assembler.h"
 #include "vm/bitfield.h"
@@ skipping 313 matching lines @@
     // Ensure that sign is preserved.
     ASSERT(loc.stack_index() == stack_index);
     return loc;
   }
 
   bool IsQuadStackSlot() const {
     return kind() == kQuadStackSlot;
   }
 
   intptr_t stack_index() const {
-    ASSERT(IsStackSlot() || IsDoubleStackSlot() || IsQuadStackSlot());
+    ASSERT(HasStackIndex());
     // Decode stack index manually to preserve sign.
     return payload() - kStackIndexBias;
   }
 
+  bool HasStackIndex() const {
+    return IsStackSlot() || IsDoubleStackSlot() || IsQuadStackSlot();
+  }
+
   // Return a memory operand for stack slot locations.
   Address ToStackSlotAddress() const;
 
   // Returns the offset from the frame pointer for stack slot locations.
   intptr_t ToStackSlotOffset() const;
 
   // Constants.
   static Location RegisterOrConstant(Value* value);
   static Location RegisterOrSmiConstant(Value* value);
   static Location FixedRegisterOrConstant(Value* value, Register reg);
   static Location FixedRegisterOrSmiConstant(Value* value, Register reg);
   static Location AnyOrConstant(Value* value);
 
   const char* Name() const;
   void PrintTo(BufferFormatter* f) const;
   void Print() const;
   const char* ToCString() const;
 
   // Compare two locations.
   bool Equals(Location other) const {
     return value_ == other.value_;
   }
 
   // If current location is constant might return something that
   // is not equal to any Kind.
   Kind kind() const {
     return KindField::decode(value_);
   }
 
+  Location Copy() const;
+
  private:
   explicit Location(uword value) : value_(value) { }
 
   Location(Kind kind, uword payload)
       : value_(KindField::encode(kind) | PayloadField::encode(payload)) { }
 
   uword payload() const {
     return PayloadField::decode(value_);
   }
 
@@ skipping 43 matching lines @@
   }
 
  private:
   static const intptr_t kPairLength = 2;
   Location locations_[kPairLength];
 };
 
 
 class RegisterSet : public ValueObject {
  public:
-  RegisterSet() : cpu_registers_(0), fpu_registers_(0) {
+  RegisterSet() : cpu_registers_(0), untagged_cpu_registers_(0),
+                  fpu_registers_(0) {
     ASSERT(kNumberOfCpuRegisters <= (kWordSize * kBitsPerByte));
     ASSERT(kNumberOfFpuRegisters <= (kWordSize * kBitsPerByte));
   }
 
 
-  void Add(Location loc) {
+  void Add(Location loc, Representation rep = kTagged) {
     if (loc.IsRegister()) {
       cpu_registers_ |= (1 << loc.reg());
+      if (rep != kTagged) {
+        // CPU register contains an untagged value.
+        MarkUntagged(loc);
+      }
     } else if (loc.IsFpuRegister()) {
       fpu_registers_ |= (1 << loc.fpu_reg());
     }
   }
 
   void Remove(Location loc) {
     if (loc.IsRegister()) {
       cpu_registers_ &= ~(1 << loc.reg());
     } else if (loc.IsFpuRegister()) {
       fpu_registers_ &= ~(1 << loc.fpu_reg());
     }
   }
 
+  void DebugPrint() {
+    for (intptr_t i = 0; i < kNumberOfCpuRegisters; i++) {
+      Register r = static_cast<Register>(i);
+      if (ContainsRegister(r)) {
+        OS::Print("%s %s\n", Assembler::RegisterName(r),
+                           IsTagged(r) ? "tagged" : "untagged");
+      }
+    }
+
+    for (intptr_t i = 0; i < kNumberOfFpuRegisters; i++) {
+      FpuRegister r = static_cast<FpuRegister>(i);
+      if (ContainsFpuRegister(r)) {
+        OS::Print("%s\n", Assembler::FpuRegisterName(r));
+      }
+    }
+  }
+
+  void MarkUntagged(Location loc) {
+    ASSERT(loc.IsRegister());
+    untagged_cpu_registers_ |= (1 << loc.reg());
+  }
+
+  bool IsTagged(Register reg) const {
+    return (untagged_cpu_registers_ & (1 << reg)) == 0;
+  }
+
   bool ContainsRegister(Register reg) const {
     return (cpu_registers_ & (1 << reg)) != 0;
   }
 
   bool ContainsFpuRegister(FpuRegister fpu_reg) const {
     return (fpu_registers_ & (1 << fpu_reg)) != 0;
   }
 
   intptr_t CpuRegisterCount() const { return RegisterCount(cpu_registers_); }
   intptr_t FpuRegisterCount() const { return RegisterCount(fpu_registers_); }
 
   static intptr_t RegisterCount(intptr_t registers);
 
   intptr_t cpu_registers() const { return cpu_registers_; }
   intptr_t fpu_registers() const { return fpu_registers_; }
 
  private:
   intptr_t cpu_registers_;
+  intptr_t untagged_cpu_registers_;
   intptr_t fpu_registers_;
 
   DISALLOW_COPY_AND_ASSIGN(RegisterSet);
 };
 
 
 // Specification of locations for inputs and output.
 class LocationSummary : public ZoneAllocated {
  public:
   enum ContainsCall {
@@ skipping 73 matching lines @@
   BitmapBuilder* stack_bitmap() const { return stack_bitmap_; }
 
   bool always_calls() const {
     return contains_call_ == kCall;
   }
 
   bool can_call() {
     return contains_call_ != kNoCall;
   }
 
+  bool HasCallOnSlowPath() {
+    return can_call() && !always_calls();
+  }
+
   void PrintTo(BufferFormatter* f) const;
 
   static LocationSummary* Make(intptr_t input_count,
                                Location out,
                                ContainsCall contains_call);
 
   RegisterSet* live_registers() {
     return &live_registers_;
   }
 
  private:
   ZoneGrowableArray<Location> input_locations_;
   ZoneGrowableArray<Location> temp_locations_;
   ZoneGrowableArray<Location> output_locations_;
 
   BitmapBuilder* stack_bitmap_;
 
   const ContainsCall contains_call_;
   RegisterSet live_registers_;
 };
 
 
 }  // namespace dart
 
 #endif  // VM_LOCATIONS_H_