Support for multiple register values

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"
 
 namespace dart {
 
 class BufferFormatter;
 class Value;
+class PairLocation;
 
 
 enum Representation {
   kNoRepresentation,
   kTagged,
   kUntagged,
   kUnboxedDouble,
   kUnboxedMint,
   kUnboxedFloat32x4,
   kUnboxedInt32x4,
   kUnboxedFloat64x2,
+  kPairOfTagged,
+  kPairOfUnboxedDouble,
   kNumRepresentations
 };
 
 
 // Location objects are used to connect register allocator and code generator.
 // Instruction templates used by code generator have a corresponding
 // LocationSummary object which specifies expected location for every input
 // and output.
 // Each location is encoded as a single word: for non-constant locations
-// low 3 bits denote location kind, rest is kind specific location payload
+// low 4 bits denote location kind, rest is kind specific location payload
 // e.g. for REGISTER kind payload is register code (value of the Register
 // enumeration), constant locations contain a tagged (low 2 bits are set to 01)
 // Object handle.
 //
 // Locations must satisfy the following invariant: if two locations' encodings
 // are bitwise unequal then these two locations are guaranteed to be disjoint.
 // Properties like representation belong to the value that is stored in
 // the location not to the location itself.
 class Location : public ValueObject {
  private:
   enum {
     // Number of bits required to encode Kind value.
     kBitsForKind = 4,
     kBitsForPayload = kWordSize * kBitsPerByte - kBitsForKind,
   };
 
   static const uword kInvalidLocation = 0;
   static const uword kConstantMask = 0x3;
 
-  static const intptr_t kMachineRegisterMask = 0x6;
-  static const intptr_t kMachineRegister = 0x6;
-
  public:
   // Constant payload can overlap with kind field so Kind values
   // have to be chosen in a way that their last 2 bits are never
-  // the same as kConstant.
+  // the same as kConstant or kPairLocation.

[Florian Schneider, 2014/04/04 11:52:46]

Maybe you can turn this comment into COMPILE_ASSERT. This would prevent mistakes
if someone does not read this comment in the future.

[Cutch, 2014/04/04 16:34:46]

Done.

   // Note that two locations with different kinds should never point to
   // the same place. For example kQuadStackSlot location should never intersect
   // with kDoubleStackSlot location.
   enum Kind {
     // This location is invalid.  Payload must be zero.
     kInvalid = 0,
 
     // Constant value. This location contains a tagged Object handle.
     kConstant = 1,
 
+    // This location contains a pointer to a PairLocation.
+    kPairLocation = 2,
+
     // Unallocated location represents a location that is not fixed and can be
     // allocated by a register allocator.  Each unallocated location has
     // a policy that specifies what kind of location is suitable. Payload
     // contains register allocation policy.
-    kUnallocated = 2,
+    kUnallocated = 3,
 
     // Spill slots allocated by the register allocator.  Payload contains
     // a spill index.
-    kStackSlot = 3,  // Word size slot.
-    kDoubleStackSlot = 4,  // 64bit stack slot.
-    kQuadStackSlot = 8,  // 128bit stack slot.
+    kStackSlot = 4,  // Word size slot.
+    kDoubleStackSlot = 7,  // 64bit stack slot.
+    kQuadStackSlot = 11,  // 128bit stack slot.
 
     // Register location represents a fixed register.  Payload contains
     // register code.
-    kRegister = 6,
+    kRegister = 8,
 
     // FpuRegister location represents a fixed fpu register.  Payload contains
     // its code.
-    kFpuRegister = 7,
+    kFpuRegister = 12,
   };
 
   Location() : value_(kInvalidLocation) {
     ASSERT(IsInvalid());
   }
 
   Location(const Location& other) : ValueObject(), value_(other.value_) { }
 
   Location& operator=(const Location& other) {
     value_ = other.value_;
@@ skipping 14 matching lines @@
     Location loc(reinterpret_cast<uword>(&obj) | kConstant);
     ASSERT(&obj == &loc.constant());
     return loc;
   }
 
   const Object& constant() const {
     ASSERT(IsConstant());
     return *reinterpret_cast<const Object*>(value_ & ~kConstantMask);
   }
 
+  bool IsPairLocation() const {
+    ASSERT((kPairLocation & kConstantMask) == kPairLocation);

[Florian Schneider, 2014/04/04 11:52:46]

Use COMPILE_ASSERT here.

[Cutch, 2014/04/04 16:34:46]

Done here and elsewhere.

+    return (value_ & kConstantMask) == kPairLocation;

[Florian Schneider, 2014/04/04 11:52:46]

kConstantMask is not the right name anymore since it is used for constants and
pairs now. Maybe rename to kConstantOrPairMask or just kTagMask?

[Cutch, 2014/04/04 16:34:46]

Renamed to kLocationTagMask.

+  }
+
+  static Location Pair(Location first, Location second);
+
+  PairLocation* AsPairLocation() const;
+
   // Unallocated locations.
   enum Policy {
     kAny,
     kPrefersRegister,
     kRequiresRegister,
     kRequiresFpuRegister,
     kWritableRegister,
     kSameAsFirstInput,
   };
 
@@ skipping 68 matching lines @@
   bool IsFpuRegister() const {
     return kind() == kFpuRegister;
   }
 
   FpuRegister fpu_reg() const {
     ASSERT(IsFpuRegister());
     return static_cast<FpuRegister>(payload());
   }
 
   static bool IsMachineRegisterKind(Kind kind) {
-    return (kind & kMachineRegisterMask) == kMachineRegister;
+    return (kind == kRegister) || (kind == kFpuRegister);
   }
 
   static Location MachineRegisterLocation(Kind kind,
                                           intptr_t reg) {
     if (kind == kRegister) {
       return RegisterLocation(static_cast<Register>(reg));
     } else {
       ASSERT(kind == kFpuRegister);
       return FpuRegisterLocation(static_cast<FpuRegister>(reg));
     }
@@ skipping 105 matching lines @@
   static const intptr_t kStackIndexBias =
       static_cast<intptr_t>(1) << (kBitsForPayload - 1);
 
   // Location either contains kind and payload fields or a tagged handle for
   // a constant locations. Values of enumeration Kind are selected in such a
   // way that none of them can be interpreted as a kConstant tag.
   uword value_;
 };
 
 
+class PairLocation : public ZoneAllocated {
+ public:
+  PairLocation() {
+    for (intptr_t i = 0; i < kPairLength; i++) {
+      ASSERT(locations_[i].IsInvalid());
+    }
+  }
+
+  intptr_t length() const { return kPairLength; }
+
+  Location At(intptr_t i) const {
+    ASSERT(i >= 0);
+    ASSERT(i < kPairLength);
+    return locations_[i];
+  }
+
+  void SetAt(intptr_t i, Location loc) {
+    ASSERT(i >= 0);
+    ASSERT(i < kPairLength);
+    locations_[i] = loc;
+  }
+
+  Location* SlotAt(intptr_t i) {
+    ASSERT(i >= 0);
+    ASSERT(i < kPairLength);
+    return &locations_[i];
+  }
+
+ private:
+  static const intptr_t kPairLength = 2;
+  Location locations_[kPairLength];
+};
+
+
 class RegisterSet : public ValueObject {
  public:
   RegisterSet() : cpu_registers_(0), fpu_registers_(0) {
     ASSERT(kNumberOfCpuRegisters <= (kWordSize * kBitsPerByte));
     ASSERT(kNumberOfFpuRegisters <= (kWordSize * kBitsPerByte));
   }
 
 
   void Add(Location loc) {
     if (loc.IsRegister()) {
@@ skipping 138 matching lines @@
   BitmapBuilder* stack_bitmap_;
 
   const ContainsCall contains_call_;
   RegisterSet live_registers_;
 };
 
 
 }  // namespace dart
 
 #endif  // VM_LOCATIONS_H_