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 678 matching lines @@
   bool getIsArg() const { return IsArgument; }
   virtual void setIsArg(bool Val = true) { IsArgument = Val; }
   bool getIsImplicitArg() const { return IsImplicitArgument; }
   void setIsImplicitArg(bool Val = true) { IsImplicitArgument = Val; }
 
   void setIgnoreLiveness() { IgnoreLiveness = true; }
   bool getIgnoreLiveness() const {
     return IgnoreLiveness || IsRematerializable;
   }
 
+  /// Returns true if the variable either has a definite stack offset, or has
+  /// the UndeterminedStackOffset such that it is guaranteed to have a definite
+  /// stack offset at emission time.
   bool hasStackOffset() const { return StackOffset != InvalidStackOffset; }
+  /// Returns true if the variable has a stack offset that is known at this
+  /// time.
+  bool hasKnownStackOffset() const {
+    return StackOffset != InvalidStackOffset &&
+           StackOffset != UndeterminedStackOffset;
+  }
   int32_t getStackOffset() const {
-    assert(hasStackOffset());
+    assert(hasKnownStackOffset());
     return StackOffset;
   }
   void setStackOffset(int32_t Offset) { StackOffset = Offset; }
+  /// Set a "placeholder" stack offset before its actual offset has been
+  /// determined.
+  void setHasStackOffset() {
+    if (!hasStackOffset())
+      StackOffset = UndeterminedStackOffset;
+  }
   /// Returns the variable's stack offset in symbolic form, to improve
   /// readability in DecorateAsm mode.
   std::string getSymbolicStackOffset() const {
     if (!BuildDefs::dump())
       return "";
     return ".L$lv$" + getName();
   }
 
   bool hasReg() const { return getRegNum().hasValue(); }
   RegNumT getRegNum() const { return RegNum; }
   void setRegNum(RegNumT NewRegNum) {
     // Regnum shouldn't be set more than once.
     assert(!hasReg() || RegNum == NewRegNum);
     RegNum = NewRegNum;
   }
   bool hasRegTmp() const { return getRegNumTmp().hasValue(); }
   RegNumT getRegNumTmp() const { return RegNumTmp; }
   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 is only certain to be accurate after register allocation and stack
+  /// slot assignment have completed.
+  Variable *getLinkedToStackRoot() const {
+    Variable *FurthestStackVar = nullptr;
+    for (Variable *Root = LinkedTo; Root != nullptr; Root = Root->LinkedTo) {
+      if (!Root->hasReg() && Root->hasStackOffset()) {
+        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 16 matching lines @@
   bool IgnoreLiveness = false;
   // If IsRematerializable, RegNum keeps track of which register (stack or frame
   // pointer), and StackOffset is the known offset from that register.
   bool IsRematerializable = false;
   RegRequirement RegRequirement = RR_MayHaveRegister;
   RegClass RegisterClass;
   /// RegNum is the allocated register, (as long as RegNum.hasValue() is true).
   RegNumT RegNum;
   /// RegNumTmp is the tentative assignment during register allocation.
   RegNumT RegNumTmp;
-  static constexpr int32_t InvalidStackOffset = -1;
+  static constexpr int32_t InvalidStackOffset =
+      std::numeric_limits<int32_t>::min();
+  static constexpr int32_t UndeterminedStackOffset =
+      1 + std::numeric_limits<int32_t>::min();
   /// StackOffset is the canonical location on stack (only if
   /// RegNum.hasNoValue() || IsArgument).
   int32_t StackOffset = InvalidStackOffset;
   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.
   Variable *LinkedTo = nullptr;
 };
@@ skipping 205 matching lines @@
     return Operand->getKind() == kVariableBoolean;
   }
 
 private:
   Variable *BoolSource = nullptr;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEOPERAND_H