Add support for undef values in ICE IR.

src/IceTargetLoweringX8632.cpp

 //===- subzero/src/IceTargetLoweringX8632.cpp - x86-32 lowering -----------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the TargetLoweringX8632 class, which
@@ skipping 2134 matching lines @@
     }
 
     if (!(Allowed & Legal_Mem)) {
       Variable *Reg = makeReg(From->getType(), RegNum);
       _mov(Reg, From, RegNum);
       From = Reg;
     }
     return From;
   }
   if (llvm::isa<Constant>(From)) {
-    if (!(Allowed & Legal_Imm)) {
+    if (llvm::isa<ConstantUndef>(From)) {
+      // Undef values are lowered to a register.

[Jim Stichnoth, 2014/06/17 06:28:07]

Maybe change "lowered to a register" to "lowered to an uninitialized register"
just to be clear, and that also makes it more clear why a FakeDef would be
needed.

Also, it wouldn't hurt to assert(Allowed & Legal_Reg), which I believe is true
for all current calls to legalize() and probably will always be true, but still.

[wala, 2014/06/17 20:38:02]

I agree that the comment needs to be clarified that undefs will be lowered to
uninitialized registers.

assert(Allowed & Legal_Reg) is already called at the beginning of the function.

+      Variable *Reg = makeReg(From->getType(), RegNum);
+      // Insert a FakeDef so that the live range of Reg is not overestimated.
+      Context.insert(InstFakeDef::create(Func, Reg));
+      From = Reg;
+    } else if (!(Allowed & Legal_Imm)) {
       Variable *Reg = makeReg(From->getType(), RegNum);
       _mov(Reg, From);
       From = Reg;
     }
     return From;
   }
   if (Variable *Var = llvm::dyn_cast<Variable>(From)) {
     // We need a new physical register for the operand if:
     //   Mem is not allowed and Var->getRegNum() is unknown, or
     //   RegNum is required and Var->getRegNum() doesn't match.
@@ skipping 95 matching lines @@
   // llvm-mc doesn't parse "dword ptr [.L$foo]".
   Str << "dword ptr [L$" << IceType_f32 << "$" << getPoolEntryID() << "]";
 }
 
 template <> void ConstantDouble::emit(GlobalContext *Ctx) const {
   Ostream &Str = Ctx->getStrEmit();
   Str << "qword ptr [L$" << IceType_f64 << "$" << getPoolEntryID() << "]";
 }
 
 } // end of namespace Ice