Subzero: Change the way bitcast stack slot lowering is handled.

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.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the Operand class and its target-independent
 // subclasses.  The main classes are Variable, which represents an
 // LLVM variable that is either register- or stack-allocated, and the
 // Constant hierarchy, which represents integer, floating-point,
 // and/or symbolic constants.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SUBZERO_SRC_ICEOPERAND_H
 #define SUBZERO_SRC_ICEOPERAND_H
 
 #include "IceDefs.h"
 #include "IceTypes.h"
 
 namespace Ice {
 
 class Operand {
 public:
+  static const size_t MaxTargetKinds = 10;
   enum OperandKind {
     kConst_Base,
     kConstInteger32,
     kConstInteger64,
     kConstFloat,
     kConstDouble,
     kConstRelocatable,
     kConstUndef,
-    kConst_Num,
+    kConst_Target, // leave space for target-specific constant kinds
+    kConst_Num = kConst_Target + MaxTargetKinds,
     kVariable,
+    kVariable_Target, // leave space for target-specific variable kinds
+    kVariable_Num = kVariable_Target + MaxTargetKinds,
     // Target-specific operand classes use kTarget as the starting
     // point for their Kind enum space.
     kTarget
   };
   OperandKind getKind() const { return Kind; }
   Type getType() const { return Ty; }
 
   // Every Operand keeps an array of the Variables referenced in
   // the operand.  This is so that the liveness operations can get
   // quick access to the variables of interest, without having to dig
@@ skipping 284 matching lines @@
   RangeType Range;
   RegWeight Weight;
 };
 
 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.
 class Variable : public Operand {
+  Variable(const Variable &) LLVM_DELETED_FUNCTION;
+  Variable &operator=(const Variable &) LLVM_DELETED_FUNCTION;
+
 public:
   static Variable *create(Cfg *Func, Type Ty, const CfgNode *Node, SizeT Index,
                           const IceString &Name) {
-    return new (Func->allocate<Variable>()) Variable(Ty, Node, Index, Name);
+    return new (Func->allocate<Variable>())
+        Variable(kVariable, Ty, Node, Index, Name);
   }
 
   SizeT getIndex() const { return Number; }
   IceString getName() const;
   void setName(IceString &NewName) {
     // Make sure that the name can only be set once.
     assert(Name.empty());
     Name = NewName;
   }
 
@@ skipping 68 matching lines @@
   // emission.  Note that only basic information is copied, in
   // particular not DefInst, IsArgument, Weight, RegisterPreference,
   // AllowRegisterOverlap, LoVar, HiVar, VarsReal.
   Variable asType(Type Ty);
 
   virtual void emit(const Cfg *Func) const;
   using Operand::dump;
   virtual void dump(const Cfg *Func, Ostream &Str) const;
 
   static bool classof(const Operand *Operand) {
-    return Operand->getKind() == kVariable;
+    OperandKind Kind = Operand->getKind();
+    return Kind >= kVariable && Kind <= kVariable_Num;
   }
 
   // The destructor is public because of the asType() method.
   virtual ~Variable() {}
 
-private:
-  Variable(Type Ty, const CfgNode *Node, SizeT Index, const IceString &Name)
-      : Operand(kVariable, Ty), Number(Index), Name(Name), DefInst(NULL),
-        DefNode(Node), IsMultidef(false), IsArgument(false), StackOffset(0),
+protected:
+  Variable(OperandKind K, Type Ty, const CfgNode *Node, SizeT Index,
+           const IceString &Name)
+      : Operand(K, Ty), Number(Index), Name(Name), DefInst(NULL), DefNode(Node),
+        IsMultidef(false), IsArgument(false), StackOffset(0),
         RegNum(NoRegister), RegNumTmp(NoRegister), Weight(1),
         RegisterPreference(NULL), AllowRegisterOverlap(false), LoVar(NULL),
         HiVar(NULL) {
     Vars = VarsReal;
     Vars[0] = this;
     NumVars = 1;
   }
-  Variable(const Variable &) LLVM_DELETED_FUNCTION;
-  Variable &operator=(const Variable &) LLVM_DELETED_FUNCTION;
   // Number is unique across all variables, and is used as a
   // (bit)vector index for liveness analysis.
   const SizeT Number;
   // Name is optional.
   IceString Name;
   // DefInst is the instruction that produces this variable as its
   // dest.
   Inst *DefInst;
   // DefNode is the node where this variable was produced, and is
   // reset to NULL if it is used outside that node.  This is used for
@@ skipping 34 matching lines @@
   Variable *LoVar;
   Variable *HiVar;
   // VarsReal (and Operand::Vars) are set up such that Vars[0] ==
   // this.
   Variable *VarsReal[1];
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEOPERAND_H