Subzero: Remove the LEAHACK workarounds.

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 491 matching lines @@
     return RegNames[RegNum];
   }
 }
 
 void TargetX8632::emitVariable(const Variable *Var) const {
   Ostream &Str = Ctx->getStrEmit();
   if (Var->hasReg()) {
     Str << "%" << getRegName(Var->getRegNum(), Var->getType());
     return;
   }
+  if (Var->getWeight().isInf())
+    llvm_unreachable("Infinite-weight Variable has no register assigned");
   const Type Ty = IceType_i32;
   int32_t Offset = Var->getStackOffset();
   if (!hasFramePointer())
     Offset += getStackAdjustment();
   if (Offset)
     Str << Offset;
   Str << "(%" << getRegName(getFrameOrStackReg(), Ty) << ")";
 }
 
 x86::Address TargetX8632::stackVarToAsmOperand(const Variable *Var) const {

[jvoung (off chromium), 2014/11/02 17:37:52]

Hmm I was seeing an assert recently building mesa, maybe it was related to this.
A mov instruction w/ a stack as dest, but the src didn't get a register or
something. Seems fixed after trying this patch locally.

[Jim Stichnoth, 2014/11/02 18:04:28]

Yeah, sorry about that... I was always in the habit of building spec2k with
-build-on-read=0, whereas -build-on-read=1 would lead to an assertion failure
somewhere else in the integrated assembler, and invalid assembly from the text
asm emitter.

This isn't the ideal place to catch these errors, but at least they should be
caught reliably now.

-  assert(!Var->hasReg());
+  if (Var->hasReg())
+    llvm_unreachable("Stack Variable has a register assigned");
+  if (Var->getWeight().isInf())
+    llvm_unreachable("Infinite-weight Variable has no register assigned");
   int32_t Offset = Var->getStackOffset();
   if (!hasFramePointer())
     Offset += getStackAdjustment();
   return x86::Address(RegX8632::getEncodedGPR(getFrameOrStackReg()), Offset);
 }
 
 void TargetX8632::lowerArguments() {
   VarList &Args = Func->getArgs();
   // The first four arguments of vector type, regardless of their
   // position relative to the other arguments in the argument list, are
@@ skipping 1310 matching lines @@
     case IceType_v8i1:
     case IceType_v16i1:
     case IceType_v16i8:
     case IceType_v8i16:
     case IceType_v4i32:
     case IceType_v4f32:
       ReturnReg = makeReg(Dest->getType(), RegX8632::Reg_xmm0);
       break;
     }
   }
-  // TODO(stichnot): LEAHACK: remove Legal_All (and use default) once
-  // a proper emitter is used.
-  Operand *CallTarget = legalize(Instr->getCallTarget(), Legal_All);
+  Operand *CallTarget = legalize(Instr->getCallTarget());
   Inst *NewCall = InstX8632Call::create(Func, ReturnReg, CallTarget);
   Context.insert(NewCall);
   if (ReturnRegHi)
     Context.insert(InstFakeDef::create(Func, ReturnRegHi));
 
   // Add the appropriate offset to esp.  The call instruction takes care
   // of resetting the stack offset during emission.
   if (ParameterAreaSizeBytes) {
     Variable *esp = Func->getTarget()->getPhysicalRegister(RegX8632::Reg_esp);
     _add(esp, Ctx->getConstantInt32(IceType_i32, ParameterAreaSizeBytes));
@@ skipping 2534 matching lines @@
       if (isVectorType(From->getType()))
         return makeVectorOfZeros(From->getType(), RegNum);
       From = Ctx->getConstantZero(From->getType());
     }
     // There should be no constants of vector type (other than undef).
     assert(!isVectorType(From->getType()));
     bool NeedsReg = false;
     if (!(Allowed & Legal_Imm))
       // Immediate specifically not allowed
       NeedsReg = true;
-    // TODO(stichnot): LEAHACK: remove Legal_Reloc once a proper
-    // emitter is used.
-    if (!(Allowed & Legal_Reloc) && llvm::isa<ConstantRelocatable>(From))
-      // Relocatable specifically not allowed
-      NeedsReg = true;
     if (!(Allowed & Legal_Mem) && isScalarFloatingType(From->getType()))
       // On x86, FP constants are lowered to mem operands.
       NeedsReg = true;
     if (NeedsReg) {
       From = copyToReg(From, RegNum);
     }
     return From;
   }
   if (Variable *Var = llvm::dyn_cast<Variable>(From)) {
     // Check if the variable is guaranteed a physical register.  This
@@ skipping 277 matching lines @@
   } else if (IsConstant || IsExternal)
     Str << "\t.zero\t" << Size << "\n";
   // Size is part of .comm.
 
   if (IsConstant || HasNonzeroInitializer || IsExternal)
     Str << "\t.size\t" << MangledName << ", " << Size << "\n";
   // Size is part of .comm.
 }
 
 } // end of namespace Ice