Subzero: Refactor tracking of Defs and block-local Variables.

src/IceInstX8632.h

 //===- subzero/src/IceInstX8632.h - Low-level x86 instructions --*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the InstX8632 and OperandX8632 classes and
@@ skipping 124 matching lines @@
   Portion Part;
 };
 
 // SpillVariable decorates a Variable by linking it to another
 // Variable.  When stack frame offsets are computed, the SpillVariable
 // is given a distinct stack slot only if its linked Variable has a
 // register.  If the linked Variable has a stack slot, then the
 // Variable and SpillVariable share that slot.
 class SpillVariable : public Variable {
 public:
-  static SpillVariable *create(Cfg *Func, Type Ty, const CfgNode *Node,
-                               SizeT Index, const IceString &Name) {
-    return new (Func->allocate<SpillVariable>())
-        SpillVariable(Ty, Node, Index, Name);
+  static SpillVariable *create(Cfg *Func, Type Ty, SizeT Index,
+                               const IceString &Name) {
+    return new (Func->allocate<SpillVariable>()) SpillVariable(Ty, Index, Name);
   }
   const static OperandKind SpillVariableKind =
       static_cast<OperandKind>(kVariable_Target);
   static bool classof(const Operand *Operand) {
     return Operand->getKind() == SpillVariableKind;
   }
   void setLinkedTo(Variable *Var) { LinkedTo = Var; }
   Variable *getLinkedTo() const { return LinkedTo; }
   // Inherit dump() and emit() from Variable.
 private:
-  SpillVariable(Type Ty, const CfgNode *Node, SizeT Index,
-                const IceString &Name)
-      : Variable(SpillVariableKind, Ty, Node, Index, Name), LinkedTo(NULL) {}
+  SpillVariable(Type Ty, SizeT Index, const IceString &Name)
+      : Variable(SpillVariableKind, Ty, Index, Name), LinkedTo(NULL) {}
   Variable *LinkedTo;
 };
 
 class InstX8632 : public InstTarget {
 public:
   enum InstKindX8632 {
     k__Start = Inst::Target,
     Adc,
     Add,
     Addps,
@@ skipping 214 matching lines @@
   CondX86::BrCond Condition;
   const CfgNode *TargetTrue;
   const CfgNode *TargetFalse;
   const InstX8632Label *Label; // Intra-block branch target
 };
 
 // AdjustStack instruction - subtracts esp by the given amount and
 // updates the stack offset during code emission.
 class InstX8632AdjustStack : public InstX8632 {
 public:
-  static InstX8632AdjustStack *create(Cfg *Func, SizeT Amount) {
+  static InstX8632AdjustStack *create(Cfg *Func, SizeT Amount, Variable *Esp) {
     return new (Func->allocate<InstX8632AdjustStack>())
-        InstX8632AdjustStack(Func, Amount);
+        InstX8632AdjustStack(Func, Amount, Esp);
   }
   virtual void emit(const Cfg *Func) const;
   virtual void dump(const Cfg *Func) const;
   static bool classof(const Inst *Inst) { return isClassof(Inst, Adjuststack); }
 
 private:
-  InstX8632AdjustStack(Cfg *Func, SizeT Amount);
+  InstX8632AdjustStack(Cfg *Func, SizeT Amount, Variable *Esp);
   InstX8632AdjustStack(const InstX8632AdjustStack &) LLVM_DELETED_FUNCTION;
   InstX8632AdjustStack &operator=(const InstX8632AdjustStack &)
       LLVM_DELETED_FUNCTION;
   SizeT Amount;
 };
 
 // Call instruction.  Arguments should have already been pushed.
 class InstX8632Call : public InstX8632 {
 public:
   static InstX8632Call *create(Cfg *Func, Variable *Dest, Operand *CallTarget) {
@@ skipping 865 matching lines @@
 template <> void InstX8632Pmuludq::emit(const Cfg *Func) const;
 template <> void InstX8632Psll::emit(const Cfg *Func) const;
 template <> void InstX8632Psra::emit(const Cfg *Func) const;
 template <> void InstX8632Psub::emit(const Cfg *Func) const;
 template <> void InstX8632Sqrtss::emit(const Cfg *Func) const;
 template <> void InstX8632Subss::emit(const Cfg *Func) const;
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEINSTX8632_H