Subzero: Local variable splitting.

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 711 matching lines @@
   void setRegNumTmp(RegNumT NewRegNum) { RegNumTmp = NewRegNum; }
 
   RegWeight getWeight(const Cfg *Func) const;
 
   void setMustHaveReg() { RegRequirement = RR_MustHaveRegister; }
   bool mustHaveReg() const { return RegRequirement == RR_MustHaveRegister; }
   void setMustNotHaveReg() { RegRequirement = RR_MustNotHaveRegister; }
   bool mustNotHaveReg() const {
     return RegRequirement == RR_MustNotHaveRegister;
   }
+  bool mayHaveReg() const { return RegRequirement == RR_MayHaveRegister; }
   void setRematerializable(RegNumT NewRegNum, int32_t NewOffset) {
     IsRematerializable = true;
     setRegNum(NewRegNum);
     setStackOffset(NewOffset);
     setMustHaveReg();
   }
   bool isRematerializable() const { return IsRematerializable; }
 
   void setRegClass(uint8_t RC) { RegisterClass = static_cast<RegClass>(RC); }
   RegClass getRegClass() const { return RegisterClass; }
@@ skipping 40 matching lines @@
   Variable *getLinkedTo() const { return LinkedTo; }
   /// Follow the LinkedTo chain up to the furthest ancestor.
   Variable *getLinkedToRoot() const {
     Variable *Root = LinkedTo;
     if (Root == nullptr)
       return nullptr;
     while (Root->LinkedTo != nullptr)
       Root = Root->LinkedTo;
     return Root;
   }
+  /// Follow the LinkedTo chain up to the furthest stack-allocated ancestor.
+  /// This only makes sense after register allocation is complete.

[Eric Holk, 2016/07/25 19:59:22]

Is there an assertion you could add to make sure register allocation has
happened?

[Jim Stichnoth, 2016/07/26 05:59:09]

I don't really think it could be done cleanly and reliably.  For example, there
can be multiple register allocation passes such as main register allocation
followed by post phi lowering register allocation.  So the assert would need to
know that *all* regalloc passes have completed.

+  Variable *getLinkedToStackRoot() const {
+    Variable *FurthestStackVar = nullptr;
+    for (Variable *Root = LinkedTo; Root != nullptr; Root = Root->LinkedTo) {
+      if (!Root->hasReg()) {
+        FurthestStackVar = Root;
+      }
+    }
+    return FurthestStackVar;
+  }
 
   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)
@@ skipping 242 matching lines @@
     return Operand->getKind() == kVariableBoolean;
   }
 
 private:
   Variable *BoolSource = nullptr;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEOPERAND_H