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.

[jvoung (off chromium), 2014/06/17 21:48:53]

The comment says it will be an unspecified bit pattern, which is still true even
if we make it 0.

However, it might be good to clarify that backends should try to make code
generation deterministic and lower to 0.

[wala, 2014/06/18 01:17:46]

Agreed; I've updated the comment.

+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