Subzero: Merge SpillVariable functionality directly into Variable.

src/IceOperand.h

 //===- subzero/src/IceOperand.h - High-level operands -----------*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 638 matching lines @@
   /// linear-scan code enables this by calling trim() on the ranges of interest
   /// as Cur advances. Note that linear-scan also has to initialize TrimmedBegin
   /// at the beginning by calling untrim().
   RangeType::const_iterator TrimmedBegin;
 };
 
 Ostream &operator<<(Ostream &Str, const LiveRange &L);
 
 /// Variable represents an operand that is register-allocated or
 /// stack-allocated. If it is register-allocated, it will ultimately have a
-/// non-negative RegNum field.
+/// valid RegNum field.
 class Variable : public Operand {
   Variable() = delete;
   Variable(const Variable &) = delete;
   Variable &operator=(const Variable &) = delete;
 
   enum RegRequirement : uint8_t {
     RR_MayHaveRegister,
     RR_MustHaveRegister,
     RR_MustNotHaveRegister,
   };
@@ skipping 96 matching lines @@
   /// instead of copying the existing assignment.
   const Variable *asType(const Cfg *Func, Type Ty, RegNumT NewRegNum) const;
 
   void emit(const Cfg *Func) const override;
   using Operand::dump;
   void dump(const Cfg *Func, Ostream &Str) const override;
 
   /// Return reg num of base register, if different from stack/frame register.
   virtual RegNumT getBaseRegNum() const { return RegNumT(); }
 
+  void setLinkedTo(const Variable *Var) {
+    // If B is linked to A, and we now want to link C to B, we instead link C to
+    // A so that we have one root (A) and all leaves (B, C) link directly to the
+    // root.
+    if (Var->getLinkedTo() != nullptr)
+      Var = Var->getLinkedTo();

[John, 2016/06/29 03:50:44]

I understand why you're using the getter here, but this "hides" the fact (that
is expressed by the comment above) that:

if Var.LinkedTo != nullptr --> Var.LinkedTo.LinkedTo == nullptr

I would probably just do:
Var = Var.LinkedTo

(and maybe put an assert before it.)

Up to you

[Jim Stichnoth, 2016/06/29 04:29:35]

Done.

+    LinkedTo = Var;
+  }
+  const Variable *getLinkedTo() const {
+    // Make sure a leaf links directly to the root.
+    if (LinkedTo != nullptr)
+      assert(LinkedTo->getLinkedTo() == nullptr);

[John, 2016/06/29 03:50:43]

perhaps:

assert(LinkedTo.LinkedTo == nullptr)

?

[Jim Stichnoth, 2016/06/29 04:29:35]

Done.

+    return LinkedTo;
+  }
+
   static bool classof(const Operand *Operand) {
     OperandKind Kind = Operand->getKind();
     return Kind >= kVariable && Kind <= kVariable_Max;
   }
 
   SizeT hashValue() const override { return std::hash<SizeT>()(getIndex()); }
 
 protected:
   Variable(const Cfg *Func, OperandKind K, Type Ty, SizeT Index)
       : Operand(K, Ty), Number(Index),
@@ skipping 21 matching lines @@
   /// RegNum is the allocated register, (as long as RegNum.hasValue() is true).
   RegNumT RegNum;
   /// RegNumTmp is the tentative assignment during register allocation.
   RegNumT RegNumTmp;
   /// StackOffset is the canonical location on stack (only if
   /// RegNum.hasNoValue() || IsArgument).
   int32_t StackOffset = 0;
   LiveRange Live;
   /// VarsReal (and Operand::Vars) are set up such that Vars[0] == this.
   Variable *VarsReal[1];
+  /// This Variable may be "linked" to another Variable, such that if neither
+  /// Variable gets a register, they are guaranteed to share a stack location.
+  const Variable *LinkedTo = nullptr;
 };
 
 // Variable64On32 represents a 64-bit variable on a 32-bit architecture. In
 // this situation the variable must be split into a low and a high word.
 class Variable64On32 : public Variable {
   Variable64On32() = delete;
   Variable64On32(const Variable64On32 &) = delete;
   Variable64On32 &operator=(const Variable64On32 &) = delete;
 
 public:
@@ skipping 196 matching lines @@
     return Operand->getKind() == kVariableBoolean;
   }
 
 private:
   Variable *BoolSource = nullptr;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEOPERAND_H