Add support for undef values in ICE IR.

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
@@ skipping 13 matching lines @@
 namespace Ice {
 
 class Operand {
 public:
   enum OperandKind {
     kConst_Base,
     kConstInteger,
     kConstFloat,
     kConstDouble,
     kConstRelocatable,
+    kConstUndef,
     kConst_Num,
     kVariable,
     // 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
@@ skipping 155 matching lines @@
         Name(Name), SuppressMangling(SuppressMangling) {}
   ConstantRelocatable(const ConstantRelocatable &) LLVM_DELETED_FUNCTION;
   ConstantRelocatable &
   operator=(const ConstantRelocatable &) LLVM_DELETED_FUNCTION;
   virtual ~ConstantRelocatable() {}
   const int64_t Offset; // fixed offset to add
   const IceString Name; // optional for debug/dump
   bool SuppressMangling;
 };
 
+// ConstantUndef represents an unspecified bit pattern. Although it is
+// legal to lower ConstantUndef to any value, backends should try to
+// make code generation deterministic by lowering ConstantUndefs to 0.
+class ConstantUndef : public Constant {
+public:
+  static ConstantUndef *create(GlobalContext *Ctx, Type Ty,
+                               uint32_t PoolEntryID) {
+    return new (Ctx->allocate<ConstantUndef>()) ConstantUndef(Ty, PoolEntryID);
+  }
+
+  using Constant::emit;
+  virtual void emit(GlobalContext *Ctx) const {
+    Ostream &Str = Ctx->getStrEmit();
+    Str << "undef";
+  }
+
+  using Constant::dump;
+  virtual void dump(GlobalContext *Ctx) const {
+    Ostream &Str = Ctx->getStrEmit();
+    Str << "undef";
+  }
+
+  static bool classof(const Operand *Operand) {
+    return Operand->getKind() == kConstUndef;
+  }
+
+private:
+  ConstantUndef(Type Ty, uint32_t PoolEntryID)
+      : Constant(kConstUndef, Ty, PoolEntryID) {}
+  ConstantUndef(const ConstantUndef &) LLVM_DELETED_FUNCTION;
+  ConstantUndef &operator=(const ConstantUndef &) LLVM_DELETED_FUNCTION;
+  virtual ~ConstantUndef() {}
+};
+
 // RegWeight is a wrapper for a uint32_t weight value, with a
 // special value that represents infinite weight, and an addWeight()
 // method that ensures that W+infinity=infinity.
 class RegWeight {
 public:
   RegWeight() : Weight(0) {}
   RegWeight(uint32_t Weight) : Weight(Weight) {}
   const static uint32_t Inf = ~0; // Force regalloc to give a register
   const static uint32_t Zero = 0; // Force regalloc NOT to give a register
   void addWeight(uint32_t Delta) {
@@ skipping 210 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