return User::operator new(s, 0);
}
public:
+ static ConstantAggregateZero* get(const Type* Ty);
+
/// isNullValue - Return true if this is the value that would be returned by
/// getNullValue.
virtual bool isNullValue() const { return true; }
friend class ConstantStruct;
friend class ConstantArray;
friend class ConstantVector;
+ friend class ConstantAggregateZero;
public:
LLVMContext();
~LLVMContext();
/// @brief Get the all ones value
Constant* getAllOnesValue(const Type* Ty);
- // UndefValue accessors
- UndefValue* getUndef(const Type* Ty);
-
// ConstantInt accessors
ConstantInt* getTrue();
ConstantInt* getFalse();
-
- // ConstantPointerNull accessors
- ConstantPointerNull* getConstantPointerNull(const PointerType* T);
-
- // ConstantAggregateZero accessors
- ConstantAggregateZero* getConstantAggregateZero(const Type* Ty);
-
+
// MDNode accessors
MDNode* getMDNode(Value* const* Vals, unsigned NumVals);
// Methods for erasing constants
void erase(MDString *M);
void erase(MDNode *M);
- void erase(ConstantAggregateZero *Z);
};
/// FOR BACKWARDS COMPATIBILITY - Returns a global context.
///
ReturnInst *CreateAggregateRet(Value * const* retVals, unsigned N) {
const Type *RetType = BB->getParent()->getReturnType();
- Value *V = Context.getUndef(RetType);
+ Value *V = UndefValue::get(RetType);
for (unsigned i = 0; i != N; ++i)
V = CreateInsertValue(V, retVals[i], i, "mrv");
return Insert(ReturnInst::Create(V));
const TargetData *TD) {
if (PHINode *PN = dyn_cast<PHINode>(I)) {
if (PN->getNumIncomingValues() == 0)
- return Context.getUndef(PN->getType());
+ return UndefValue::get(PN->getType());
Constant *Result = dyn_cast<Constant>(PN->getIncomingValue(0));
if (Result == 0) return 0;
} else if (isa<ConstantAggregateZero>(C)) {
C = Context.getNullValue(STy->getElementType(El));
} else if (isa<UndefValue>(C)) {
- C = Context.getUndef(STy->getElementType(El));
+ C = UndefValue::get(STy->getElementType(El));
} else {
return 0;
}
else if (isa<ConstantAggregateZero>(C))
C = Context.getNullValue(ATy->getElementType());
else if (isa<UndefValue>(C))
- C = Context.getUndef(ATy->getElementType());
+ C = UndefValue::get(ATy->getElementType());
else
return 0;
} else if (const VectorType *PTy = dyn_cast<VectorType>(*I)) {
else if (isa<ConstantAggregateZero>(C))
C = Context.getNullValue(PTy->getElementType());
else if (isa<UndefValue>(C))
- C = Context.getUndef(PTy->getElementType());
+ C = UndefValue::get(PTy->getElementType());
else
return 0;
} else {
// If empty string then use a i8* null instead.
if (String.empty())
- return Slot = VMContext.getConstantPointerNull(DestTy);
+ return Slot = ConstantPointerNull::get(DestTy);
// Construct string as an llvm constant.
Constant *ConstStr = ConstantArray::get(String);
const Type *IndexedType = ExtractValueInst::getIndexedType(From->getType(),
idx_begin,
idx_end);
- Value *To = Context.getUndef(IndexedType);
+ Value *To = UndefValue::get(IndexedType);
SmallVector<unsigned, 10> Idxs(idx_begin, idx_end);
unsigned IdxSkip = Idxs.size();
const CompositeType *PTy = cast<CompositeType>(V->getType());
if (isa<UndefValue>(V))
- return Context.getUndef(ExtractValueInst::getIndexedType(PTy,
+ return UndefValue::get(ExtractValueInst::getIndexedType(PTy,
idx_begin,
idx_end));
else if (isa<ConstantAggregateZero>(V))
I = ForwardRefVals.begin(), E = ForwardRefVals.end(); I != E; ++I)
if (!isa<BasicBlock>(I->second.first)) {
I->second.first->replaceAllUsesWith(
- P.getContext().getUndef(I->second.first->getType()));
+ UndefValue::get(I->second.first->getType()));
delete I->second.first;
I->second.first = 0;
}
I = ForwardRefValIDs.begin(), E = ForwardRefValIDs.end(); I != E; ++I)
if (!isa<BasicBlock>(I->second.first)) {
I->second.first->replaceAllUsesWith(
- P.getContext().getUndef(I->second.first->getType()));
+ UndefValue::get(I->second.first->getType()));
delete I->second.first;
I->second.first = 0;
}
case ValID::t_Null:
if (!isa<PointerType>(Ty))
return Error(ID.Loc, "null must be a pointer type");
- V = Con
text.getConstantPointerNull(cast<PointerType>(Ty));
+ V = Con
stantPointerNull::get(cast<PointerType>(Ty));
return false;
case ValID::t_Undef:
// FIXME: LabelTy should not be a first-class type.
if ((!Ty->isFirstClassType() || Ty == Type::LabelTy) &&
!isa<OpaqueType>(Ty))
return Error(ID.Loc, "invalid type for undef constant");
- V = Context.getUndef(Ty);
+ V = UndefValue::get(Ty);
return false;
case ValID::t_EmptyArray:
if (!isa<ArrayType>(Ty) || cast<ArrayType>(Ty)->getNumElements() != 0)
return Error(ID.Loc, "invalid empty array initializer");
- V = Context.getUndef(Ty);
+ V = UndefValue::get(Ty);
return false;
case ValID::t_Zero:
// FIXME: LabelTy should not be a first-class type.
RVs.push_back(RV);
}
- RV = Context.getUndef(PFS.getFunction().getReturnType());
+ RV = UndefValue::get(PFS.getFunction().getReturnType());
for (unsigned i = 0, e = RVs.size(); i != e; ++i) {
Instruction *I = InsertValueInst::Create(RV, RVs[i], i, "mrv");
BB->getInstList().push_back(I);
}
explicit ConstantPlaceHolder(const Type *Ty, LLVMContext& Context)
: ConstantExpr(Ty, Instruction::UserOp1, &Op<0>(), 1) {
- Op<0>() = Context.getUndef(Type::Int32Ty);
+ Op<0>() = UndefValue::get(Type::Int32Ty);
}
/// @brief Methods to support type inquiry through isa, cast, and dyn_cast.
switch (BitCode) {
default: // Default behavior: unknown constant
case bitc::CST_CODE_UNDEF: // UNDEF
- V = Context.getUndef(CurTy);
+ V = UndefValue::get(CurTy);
break;
case bitc::CST_CODE_SETTYPE: // SETTYPE: [typeid]
if (Record.empty())
else if (CurTy == Type::PPC_FP128Ty)
V = ConstantFP::get(Context, APFloat(APInt(128, 2, &Record[0])));
else
- V = Context.getUndef(CurTy);
+ V = UndefValue::get(CurTy);
break;
}
Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy));
V = ConstantVector::get(Elts);
} else {
- V = Context.getUndef(CurTy);
+ V = UndefValue::get(CurTy);
}
break;
}
if (Record.size() < 3) return Error("Invalid CE_BINOP record");
int Opc = GetDecodedBinaryOpcode(Record[0], CurTy);
if (Opc < 0) {
- V = Context.getUndef(CurTy); // Unknown binop.
+ V = UndefValue::get(CurTy); // Unknown binop.
} else {
Constant *LHS = ValueList.getConstantFwdRef(Record[1], CurTy);
Constant *RHS = ValueList.getConstantFwdRef(Record[2], CurTy);
if (Record.size() < 3) return Error("Invalid CE_CAST record");
int Opc = GetDecodedCastOpcode(Record[0]);
if (Opc < 0) {
- V = Context.getUndef(CurTy); // Unknown cast.
+ V = UndefValue::get(CurTy); // Unknown cast.
} else {
const Type *OpTy = getTypeByID(Record[1]);
if (!OpTy) return Error("Invalid CE_CAST record");
if (Vs.size() > 1 ||
(isa<StructType>(ReturnType) &&
(Vs.empty() || Vs[0]->getType() != ReturnType))) {
- Value *RV = Context.getUndef(ReturnType);
+ Value *RV = UndefValue::get(ReturnType);
for (unsigned i = 0, e = Vs.size(); i != e; ++i) {
I = InsertValueInst::Create(RV, Vs[i], i, "mrv");
CurBB->getInstList().push_back(I);
// We found at least one unresolved value. Nuke them all to avoid leaks.
for (unsigned i = ModuleValueListSize, e = ValueList.size(); i != e; ++i){
if ((A = dyn_cast<Argument>(ValueList.back())) && A->getParent() == 0) {
- A->replaceAllUsesWith(Context.getUndef(A->getType()));
+ A->replaceAllUsesWith(UndefValue::get(A->getType()));
delete A;
}
}
/// ExpandBUILD_VECTOR - Expand a BUILD_VECTOR node on targets that don't
/// support the operation, but do support the resultant vector type.
SDValue SelectionDAGLegalize::ExpandBUILD_VECTOR(SDNode *Node) {
- LLVMContext *Context = DAG.getContext();
unsigned NumElems = Node->getNumOperands();
SDValue Value1, Value2;
DebugLoc dl = Node->getDebugLoc();
} else {
assert(Node->getOperand(i).getOpcode() == ISD::UNDEF);
const Type *OpNTy = OpVT.getTypeForMVT();
- CV.push_back(Context->getUndef(OpNTy));
+ CV.push_back(UndefValue::get(OpNTy));
}
}
Constant *CP = ConstantVector::get(CV);
}
if (ExtraArgHack)
- Args.push_back(Context.getUndef(Type::Int32Ty));
+ Args.push_back(UndefValue::get(Type::Int32Ty));
// Push any varargs arguments on the list. Don't forget their attributes.
for (CallSite::arg_iterator E = CS.arg_end(); I != E; ++I, ++i) {
// extract/insertvalue chaining and let instcombine clean that up.
//
// Start out building up our return value from undef
- Value *RetVal = Context.getUndef(RetTy);
+ Value *RetVal = UndefValue::get(RetTy);
for (unsigned i = 0; i != RetCount; ++i)
if (NewRetIdxs[i] != -1) {
Value *V;
// clean that up.
Value *OldRet = RI->getOperand(0);
// Start out building up our return value from undef
- RetVal = Context.getUndef(NRetTy);
+ RetVal = UndefValue::get(NRetTy);
for (unsigned i = 0; i != RetCount; ++i)
if (NewRetIdxs[i] != -1) {
ExtractValueInst *EV = ExtractValueInst::Create(OldRet, i,
} else if (isa<UndefValue>(Agg)) {
if (const StructType *STy = dyn_cast<StructType>(Agg->getType())) {
if (IdxV < STy->getNumElements())
- return Context.getUndef(STy->getElementType(IdxV));
+ return UndefValue::get(STy->getElementType(IdxV));
} else if (const SequentialType *STy =
dyn_cast<SequentialType>(Agg->getType())) {
- return Context.getUndef(STy->getElementType());
+ return UndefValue::get(STy->getElementType());
}
}
return 0;
// FIXME: This new global should have the alignment returned by malloc. Code
// could depend on malloc returning large alignment (on the mac, 16 bytes) but
// this would only guarantee some lower alignment.
- Constant *Init = Context.getUndef(MI->getAllocatedType());
+ Constant *Init = UndefValue::get(MI->getAllocatedType());
GlobalVariable *NewGV = new GlobalVariable(*GV->getParent(),
MI->getAllocatedType(), false,
GlobalValue::InternalLinkage, Init,
Elts.push_back(Context.getNullValue(STy->getElementType(i)));
} else if (isa<UndefValue>(Init)) {
for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i)
- Elts.push_back(Context.getUndef(STy->getElementType(i)));
+ Elts.push_back(UndefValue::get(STy->getElementType(i)));
} else {
llvm_unreachable("This code is out of sync with "
" ConstantFoldLoadThroughGEPConstantExpr");
Constant *Elt = Context.getNullValue(ATy->getElementType());
Elts.assign(ATy->getNumElements(), Elt);
} else if (isa<UndefValue>(Init)) {
- Constant *Elt = Context.getUndef(ATy->getElementType());
+ Constant *Elt = UndefValue::get(ATy->getElementType());
Elts.assign(ATy->getNumElements(), Elt);
} else {
llvm_unreachable("This code is out of sync with "
const Type *Ty = AI->getType()->getElementType();
AllocaTmps.push_back(new GlobalVariable(Context, Ty, false,
GlobalValue::InternalLinkage,
- Context.getUndef(Ty),
+ UndefValue::get(Ty),
AI->getName()));
InstResult = AllocaTmps.back();
} else if (CallInst *CI = dyn_cast<CallInst>(CurInst)) {
continue;
Value *V = ArgumentConstants[i].first;
- if (V == 0) V = F.getContext().getUndef(AI->getType());
+ if (V == 0) V = UndefValue::get(AI->getType());
AI->replaceAllUsesWith(V);
++NumArgumentsProped;
MadeChange = true;
const StructType *STy = dyn_cast<StructType>(F.getReturnType());
if (STy)
for (unsigned i = 0, e = STy->getNumElements(); i < e; ++i)
- RetVals.push_back(Context.getUndef(STy->getElementType(i)));
+ RetVals.push_back(UndefValue::get(STy->getElementType(i)));
else
- RetVals.push_back(Context.getUndef(F.getReturnType()));
+ RetVals.push_back(UndefValue::get(F.getReturnType()));
unsigned NumNonConstant = 0;
for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB)
Removed = &BB->back();
// If the removed instructions have any users, replace them now.
if (!Removed->use_empty())
- Removed->replaceAllUsesWith(
- Inst->getContext().getUndef(Removed->getType()));
+ Removed->replaceAllUsesWith(UndefValue::get(Removed->getType()));
Removed->eraseFromParent();
} while (Removed != Inst);
} else if (InvokeInst *II = dyn_cast<InvokeInst>(I))
CGN->removeCallEdgeFor(II);
if (!I->use_empty())
- I->replaceAllUsesWith(BB->getContext().getUndef(I->getType()));
+ I->replaceAllUsesWith(UndefValue::get(I->getType()));
}
// Get the list of successors of this block.
// Find the malloc/free prototypes...
doInitialization(M);
- LLVMContext &Context = M.getContext();
-
bool Changed = false;
// First, process all of the malloc calls...
// Delete the old call site
if (I->getType() != Type::VoidTy)
- I->replaceAllUsesWith(Context.getUndef(I->getType()));
+ I->replaceAllUsesWith(UndefValue::get(I->getType()));
I->eraseFromParent();
Changed = true;
++NumRaised;
if (!GV) continue;
if (!GV->use_empty() && llvmUsedValues.count(I) == 0) {
if (GV->getName().startswith("llvm.dbg")) {
- GV->replaceAllUsesWith(M.getContext().getUndef(GV->getType()));
+ GV->replaceAllUsesWith(UndefValue::get(GV->getType()));
}
}
}
} else {
// If this profiling instrumentation doesn't have a constant array, just
// pass null.
- Args[2] = Context.getConstantPointerNull(UIntPtr);
+ Args[2] = ConstantPointerNull::get(UIntPtr);
}
Args[3] = ConstantInt::get(Type::Int32Ty, NumElements);
// If the block is unreachable, just return undef, since this path
// can't actually occur at runtime.
if (!DT->isReachableFromEntry(BB))
- return Phis[BB] = BB->getContext().getUndef(orig->getType());
+ return Phis[BB] = UndefValue::get(orig->getType());
if (BasicBlock *Pred = BB->getSinglePredecessor()) {
Value *ret = GetValueForBlock(Pred, orig, Phis);
// Loading the allocation -> undef.
if (isa<AllocationInst>(DepInst)) {
- ValuesPerBlock.push_back(std::make_pair(DepBB,
- DepBB->getContext().getUndef(LI->getType())));
+ ValuesPerBlock.push_back(std::make_pair(DepBB,
+ UndefValue::get(LI->getType())));
continue;
}
// undef value. This can happen when loading for a fresh allocation with no
// intervening stores, for example.
if (isa<AllocationInst>(DepInst)) {
- L->replaceAllUsesWith(DepInst->getContext().getUndef(L->getType()));
+ L->replaceAllUsesWith(UndefValue::get(L->getType()));
toErase.push_back(L);
NumGVNLoad++;
return true;
}
if (NewPred == CmpInst::BAD_ICMP_PREDICATE) return;
- LLVMContext &Context = PH->getContext();
-
// Insert new integer induction variable.
PHINode *NewPHI = PHINode::Create(Type::Int32Ty,
PH->getName()+".int", PH);
RecursivelyDeleteTriviallyDeadInstructions(EC);
// Delete old, floating point, increment instruction.
- Incr->replaceAllUsesWith(Context.getUndef(Incr->getType()));
+ Incr->replaceAllUsesWith(UndefValue::get(Incr->getType()));
RecursivelyDeleteTriviallyDeadInstructions(Incr);
// Replace floating induction variable, if it isn't already deleted.
if (Instruction *Op = dyn_cast<Instruction>(*i)) {
AddToWorkList(Op);
// Set the operand to undef to drop the use.
- *i = Context->getUndef(Op->getType());
+ *i = UndefValue::get(Op->getType());
}
return R;
} else {
// If we are replacing the instruction with itself, this must be in a
// segment of unreachable code, so just clobber the instruction.
- I.replaceAllUsesWith(Context->getUndef(I.getType()));
+ I.replaceAllUsesWith(UndefValue::get(I.getType()));
return &I;
}
}
if (DemandedMask == 0) { // Not demanding any bits from V.
if (isa<UndefValue>(V))
return 0;
- return Context->getUndef(VTy);
+ return UndefValue::get(VTy);
}
if (Depth == 6) // Limit search depth.
return 0;
} else if (DemandedElts == 0) { // If nothing is demanded, provide undef.
UndefElts = EltMask;
- return Context->getUndef(V->getType());
+ return UndefValue::get(V->getType());
}
UndefElts = 0;
if (ConstantVector *CP = dyn_cast<ConstantVector>(V)) {
const Type *EltTy = cast<VectorType>(V->getType())->getElementType();
- Constant *Undef = Context->getUndef(EltTy);
+ Constant *Undef = UndefValue::get(EltTy);
std::vector<Constant*> Elts;
for (unsigned i = 0; i != VWidth; ++i)
const Type *EltTy = cast<VectorType>(V->getType())->getElementType();
Constant *Zero = Context->getNullValue(EltTy);
- Constant *Undef = Context->getUndef(EltTy);
+ Constant *Undef = UndefValue::get(EltTy);
std::vector<Constant*> Elts;
for (unsigned i = 0; i != VWidth; ++i) {
Constant *Elt = DemandedElts[i] ? Zero : Undef;
std::vector<Constant*> Elts;
for (unsigned i = 0; i < VWidth; ++i) {
if (UndefElts[i])
- Elts.push_back(Context->getUndef(Type::Int32Ty));
+ Elts.push_back(UndefValue::get(Type::Int32Ty));
else
Elts.push_back(ConstantInt::get(Type::Int32Ty,
Shuffle->getMaskValue(i)));
Instruction *New =
InsertElementInst::Create(
- Context->getUndef(II->getType()), TmpV,
+ UndefValue::get(II->getType()), TmpV,
ConstantInt::get(Type::Int32Ty, 0U, false), II->getName());
InsertNewInstBefore(New, *II);
AddSoonDeadInstToWorklist(*II, 0);
if (ConstantInt *RHS = dyn_cast<ConstantInt>(Op1)) {
// X % 0 == undef, we don't need to preserve faults!
if (RHS->equalsInt(0))
- return ReplaceInstUsesWith(I, Context->getUndef(I.getType()));
+ return ReplaceInstUsesWith(I, UndefValue::get(I.getType()));
if (RHS->equalsInt(1)) // X % 1 == 0
return ReplaceInstUsesWith(I, Context->getNullValue(I.getType()));
}
if (isa<UndefValue>(Op1)) // fcmp pred X, undef -> undef
- return ReplaceInstUsesWith(I, Context->getUndef(Type::Int1Ty));
+ return ReplaceInstUsesWith(I, UndefValue::get(Type::Int1Ty));
// Handle fcmp with constant RHS
if (Constant *RHSC = dyn_cast<Constant>(Op1)) {
I.isTrueWhenEqual()));
if (isa<UndefValue>(Op1)) // X icmp undef -> undef
- return ReplaceInstUsesWith(I, Context->getUndef(Type::Int1Ty));
+ return ReplaceInstUsesWith(I, UndefValue::get(Type::Int1Ty));
// icmp <global/alloca*/null>, <global/alloca*/null> - Global/Stack value
// addresses never equal each other! We already know that Op0 != Op1.
if (!isa<VectorType>(SrcTy)) {
Value *Elem = InsertCastBefore(Instruction::BitCast, Src,
DestVTy->getElementType(), CI);
- return InsertElementInst::Create(Context->getUndef(DestTy), Elem,
+ return InsertElementInst::Create(UndefValue::get(DestTy), Elem,
Context->getNullValue(Type::Int32Ty));
}
// FIXME: Canonicalize bitcast(insertelement) -> insertelement(bitcast)
// Cast the input vectors to byte vectors.
Value *Op0 =InsertBitCastBefore(II->getOperand(1),Mask->getType(),CI);
Value *Op1 =InsertBitCastBefore(II->getOperand(2),Mask->getType(),CI);
- Value *Result = Context->getUndef(Op0->getType());
+ Value *Result = UndefValue::get(Op0->getType());
// Only extract each element once.
Value *ExtractedElts[32];
// If the call and callee calling conventions don't match, this call must
// be unreachable, as the call is undefined.
new StoreInst(Context->getTrue(),
- Context->getUndef(PointerType::getUnqual(Type::Int1Ty)),
+ UndefValue::get(PointerType::getUnqual(Type::Int1Ty)),
OldCall);
if (!OldCall->use_empty())
- OldCall->replaceAllUsesWith(Context->getUndef(OldCall->getType()));
+ OldCall->replaceAllUsesWith(UndefValue::get(OldCall->getType()));
if (isa<CallInst>(OldCall)) // Not worth removing an invoke here.
return EraseInstFromFunction(*OldCall);
return 0;
// undef so that we know that this code is not reachable, despite the fact
// that we can't modify the CFG here.
new StoreInst(Context->getTrue(),
- Context->getUndef(PointerType::getUnqual(Type::Int1Ty)),
+ UndefValue::get(PointerType::getUnqual(Type::Int1Ty)),
CS.getInstruction());
if (!CS.getInstruction()->use_empty())
CS.getInstruction()->
- replaceAllUsesWith(Context->getUndef(CS.getInstruction()->getType()));
+ replaceAllUsesWith(UndefValue::get(CS.getInstruction()->getType()));
if (InvokeInst *II = dyn_cast<InvokeInst>(CS.getInstruction())) {
// Don't break the CFG, insert a dummy cond branch.
}
AddUsersToWorkList(*Caller);
} else {
- NV = Context->getUndef(Caller->getType());
+ NV = UndefValue::get(Caller->getType());
}
}
SmallPtrSet<PHINode*, 16> PotentiallyDeadPHIs;
PotentiallyDeadPHIs.insert(&PN);
if (DeadPHICycle(PU, PotentiallyDeadPHIs))
- return ReplaceInstUsesWith(PN, Context->getUndef(PN.getType()));
+ return ReplaceInstUsesWith(PN, UndefValue::get(PN.getType()));
}
// If this phi has a single use, and if that use just computes a value for
if (PHIUser->hasOneUse() &&
(isa<BinaryOperator>(PHIUser) || isa<GetElementPtrInst>(PHIUser)) &&
PHIUser->use_back() == &PN) {
- return ReplaceInstUsesWith(PN, Context->getUndef(PN.getType()));
+ return ReplaceInstUsesWith(PN, UndefValue::get(PN.getType()));
}
}
return ReplaceInstUsesWith(GEP, PtrOp);
if (isa<UndefValue>(GEP.getOperand(0)))
- return ReplaceInstUsesWith(GEP, Context->getUndef(GEP.getType()));
+ return ReplaceInstUsesWith(GEP, UndefValue::get(GEP.getType()));
bool HasZeroPointerIndex = false;
if (Constant *C = dyn_cast<Constant>(GEP.getOperand(1)))
if (isa<UndefValue>(Op)) {
// Insert a new store to null because we cannot modify the CFG here.
new StoreInst(Context->getTrue(),
- Context->getUndef(PointerType::getUnqual(Type::Int1Ty)), &FI);
+ UndefValue::get(PointerType::getUnqual(Type::Int1Ty)), &FI);
return EraseInstFromFunction(FI);
}
// that this code is not reachable. We do this instead of inserting
// an unreachable instruction directly because we cannot modify the
// CFG.
- new StoreInst(Context->getUndef(LI.getType()),
+ new StoreInst(UndefValue::get(LI.getType()),
Context->getNullValue(Op->getType()), &LI);
- return ReplaceInstUsesWith(LI, Context->getUndef(LI.getType()));
+ return ReplaceInstUsesWith(LI, UndefValue::get(LI.getType()));
}
}
// Insert a new store to null instruction before the load to indicate that
// this code is not reachable. We do this instead of inserting an
// unreachable instruction directly because we cannot modify the CFG.
- new StoreInst(Context->getUndef(LI.getType()),
+ new StoreInst(UndefValue::get(LI.getType()),
Context->getNullValue(Op->getType()), &LI);
- return ReplaceInstUsesWith(LI, Context->getUndef(LI.getType()));
+ return ReplaceInstUsesWith(LI, UndefValue::get(LI.getType()));
}
// Instcombine load (constant global) into the value loaded.
// that this code is not reachable. We do this instead of inserting
// an unreachable instruction directly because we cannot modify the
// CFG.
- new StoreInst(Context->getUndef(LI.getType()),
+ new StoreInst(UndefValue::get(LI.getType()),
Context->getNullValue(Op->getType()), &LI);
- return ReplaceInstUsesWith(LI, Context->getUndef(LI.getType()));
+ return ReplaceInstUsesWith(LI, UndefValue::get(LI.getType()));
}
} else if (CE->isCast()) {
if (GV->getInitializer()->isNullValue())
return ReplaceInstUsesWith(LI, Context->getNullValue(LI.getType()));
else if (isa<UndefValue>(GV->getInitializer()))
- return ReplaceInstUsesWith(LI, Context->getUndef(LI.getType()));
+ return ReplaceInstUsesWith(LI, UndefValue::get(LI.getType()));
}
}
if (isa<ConstantPointerNull>(Ptr) &&
cast<PointerType>(Ptr->getType())->getAddressSpace() == 0) {
if (!isa<UndefValue>(Val)) {
- SI.setOperand(0, Context->getUndef(Val->getType()));
+ SI.setOperand(0, UndefValue::get(Val->getType()));
if (Instruction *U = dyn_cast<Instruction>(Val))
AddToWorkList(U); // Dropped a use.
++NumCombined;
if (Constant *C = dyn_cast<Constant>(Agg)) {
if (isa<UndefValue>(C))
- return ReplaceInstUsesWith(EV, Context->getUndef(EV.getType()));
+ return ReplaceInstUsesWith(EV, UndefValue::get(EV.getType()));
if (isa<ConstantAggregateZero>(C))
return ReplaceInstUsesWith(EV, Context->getNullValue(EV.getType()));
const VectorType *PTy = cast<VectorType>(V->getType());
unsigned Width = PTy->getNumElements();
if (EltNo >= Width) // Out of range access.
- return Context->getUndef(PTy->getElementType());
+ return UndefValue::get(PTy->getElementType());
if (isa<UndefValue>(V))
- return Context->getUndef(PTy->getElementType());
+ return UndefValue::get(PTy->getElementType());
else if (isa<ConstantAggregateZero>(V))
return Context->getNullValue(PTy->getElementType());
else if (ConstantVector *CP = dyn_cast<ConstantVector>(V))
else if (InEl < LHSWidth*2)
return FindScalarElement(SVI->getOperand(1), InEl - LHSWidth, Context);
else
- return Context->getUndef(PTy->getElementType());
+ return UndefValue::get(PTy->getElementType());
}
// Otherwise, we don't know.
Instruction *InstCombiner::visitExtractElementInst(ExtractElementInst &EI) {
// If vector val is undef, replace extract with scalar undef.
if (isa<UndefValue>(EI.getOperand(0)))
- return ReplaceInstUsesWith(EI, Context->getUndef(EI.getType()));
+ return ReplaceInstUsesWith(EI, UndefValue::get(EI.getType()));
// If vector val is constant 0, replace extract with scalar 0.
if (isa<ConstantAggregateZero>(EI.getOperand(0)))
// If this is extracting an invalid index, turn this into undef, to avoid
// crashing the code below.
if (IndexVal >= VectorWidth)
- return ReplaceInstUsesWith(EI, Context->getUndef(EI.getType()));
+ return ReplaceInstUsesWith(EI, UndefValue::get(EI.getType()));
// This instruction only demands the single element from the input vector.
// If the input vector has a single use, simplify it based on this use
SrcIdx -= LHSWidth;
Src = SVI->getOperand(1);
} else {
- return ReplaceInstUsesWith(EI, Context->getUndef(EI.getType()));
+ return ReplaceInstUsesWith(EI, UndefValue::get(EI.getType()));
}
return ExtractElementInst::Create(Src,
ConstantInt::get(Type::Int32Ty, SrcIdx, false));
unsigned NumElts = cast<VectorType>(V->getType())->getNumElements();
if (isa<UndefValue>(V)) {
- Mask.assign(NumElts, Context->getUndef(Type::Int32Ty));
+ Mask.assign(NumElts, UndefValue::get(Type::Int32Ty));
return true;
} else if (V == LHS) {
for (unsigned i = 0; i != NumElts; ++i)
// transitively ok.
if (CollectSingleShuffleElements(VecOp, LHS, RHS, Mask, Context)) {
// If so, update the mask to reflect the inserted undef.
- Mask[InsertedIdx] = Context->getUndef(Type::Int32Ty);
+ Mask[InsertedIdx] = UndefValue::get(Type::Int32Ty);
return true;
}
} else if (ExtractElementInst *EI = dyn_cast<ExtractElementInst>(ScalarOp)){
unsigned NumElts = cast<VectorType>(V->getType())->getNumElements();
if (isa<UndefValue>(V)) {
- Mask.assign(NumElts, Context->getUndef(Type::Int32Ty));
+ Mask.assign(NumElts, UndefValue::get(Type::Int32Ty));
return V;
} else if (isa<ConstantAggregateZero>(V)) {
Mask.assign(NumElts, ConstantInt::get(Type::Int32Ty, 0));
return ReplaceInstUsesWith(IE, VecOp);
if (InsertedIdx >= NumVectorElts) // Out of range insert.
- return ReplaceInstUsesWith(IE, Context->getUndef(IE.getType()));
+ return ReplaceInstUsesWith(IE, UndefValue::get(IE.getType()));
// If we are extracting a value from a vector, then inserting it right
// back into the same place, just use the input vector.
// Build a new shuffle mask.
std::vector<Constant*> Mask;
if (isa<UndefValue>(VecOp))
- Mask.assign(NumVectorElts, Context->getUndef(Type::Int32Ty));
+ Mask.assign(NumVectorElts, UndefValue::get(Type::Int32Ty));
else {
assert(isa<ConstantAggregateZero>(VecOp) && "Unknown thing");
Mask.assign(NumVectorElts, ConstantInt::get(Type::Int32Ty,
std::vector<Constant*> Mask;
Value *RHS = 0;
Value *LHS = CollectShuffleElements(&IE, Mask, RHS, Context);
- if (RHS == 0) RHS = Context->getUndef(LHS->getType());
+ if (RHS == 0) RHS = UndefValue::get(LHS->getType());
// We now have a shuffle of LHS, RHS, Mask.
return new ShuffleVectorInst(LHS, RHS,
ConstantVector::get(Mask));
// Undefined shuffle mask -> undefined value.
if (isa<UndefValue>(SVI.getOperand(2)))
- return ReplaceInstUsesWith(SVI, Context->getUndef(SVI.getType()));
+ return ReplaceInstUsesWith(SVI, UndefValue::get(SVI.getType()));
unsigned VWidth = cast<VectorType>(SVI.getType())->getNumElements();
std::vector<Constant*> Elts;
for (unsigned i = 0, e = Mask.size(); i != e; ++i) {
if (Mask[i] >= 2*e)
- Elts.push_back(Context->getUndef(Type::Int32Ty));
+ Elts.push_back(UndefValue::get(Type::Int32Ty));
else {
if ((Mask[i] >= e && isa<UndefValue>(RHS)) ||
(Mask[i] < e && isa<UndefValue>(LHS))) {
Mask[i] = 2*e; // Turn into undef.
- Elts.push_back(Context->getUndef(Type::Int32Ty));
+ Elts.push_back(UndefValue::get(Type::Int32Ty));
} else {
Mask[i] = Mask[i] % e; // Force to LHS.
Elts.push_back(ConstantInt::get(Type::Int32Ty, Mask[i]));
}
}
SVI.setOperand(0, SVI.getOperand(1));
- SVI.setOperand(1, Context->getUndef(RHS->getType()));
+ SVI.setOperand(1, UndefValue::get(RHS->getType()));
SVI.setOperand(2, ConstantVector::get(Elts));
LHS = SVI.getOperand(0);
RHS = SVI.getOperand(1);
std::vector<Constant*> Elts;
for (unsigned i = 0, e = NewMask.size(); i != e; ++i) {
if (NewMask[i] >= LHSInNElts*2) {
- Elts.push_back(Context->getUndef(Type::Int32Ty));
+ Elts.push_back(UndefValue::get(Type::Int32Ty));
} else {
Elts.push_back(ConstantInt::get(Type::Int32Ty, NewMask[i]));
}
Changed = true;
}
if (!I->use_empty())
- I->replaceAllUsesWith(Context->getUndef(I->getType()));
+ I->replaceAllUsesWith(UndefValue::get(I->getType()));
I->eraseFromParent();
}
}
// If the returned value is the load itself, replace with an undef. This can
// only happen in dead loops.
- if (AvailableVal == LI) AvailableVal =
- AvailableVal->getContext().getUndef(LI->getType());
+ if (AvailableVal == LI) AvailableVal = UndefValue::get(LI->getType());
LI->replaceAllUsesWith(AvailableVal);
LI->eraseFromParent();
return true;
// Instruction is not used, just delete it.
CurAST->deleteValue(&I);
if (!I.use_empty()) // If I has users in unreachable blocks, eliminate.
- I.replaceAllUsesWith(Context.getUndef(I.getType()));
+ I.replaceAllUsesWith(UndefValue::get(I.getType()));
I.eraseFromParent();
} else {
// Move the instruction to the start of the exit block, after any PHI
// The instruction is actually dead if there ARE NO exit blocks.
CurAST->deleteValue(&I);
if (!I.use_empty()) // If I has users in unreachable blocks, eliminate.
- I.replaceAllUsesWith(Context.getUndef(I.getType()));
+ I.replaceAllUsesWith(UndefValue::get(I.getType()));
I.eraseFromParent();
} else {
// Otherwise, if we have multiple exits, use the PromoteMem2Reg function to
// Anything that uses the instructions in this basic block should have their
// uses replaced with undefs.
if (!I->use_empty())
- I->replaceAllUsesWith(I->getContext().getUndef(I->getType()));
+ I->replaceAllUsesWith(UndefValue::get(I->getType()));
}
// If this is the edge to the header block for a loop, remove the loop and
Ops.push_back(ValueEntry(getRank(RHS), RHS));
// Clear the leaves out.
- I->setOperand(0, Context.getUndef(I->getType()));
- I->setOperand(1, Context.getUndef(I->getType()));
+ I->setOperand(0, UndefValue::get(I->getType()));
+ I->setOperand(1, UndefValue::get(I->getType()));
return;
} else {
// Turn X+(Y+Z) -> (Y+Z)+X
Ops.push_back(ValueEntry(getRank(RHS), RHS));
// Clear the RHS leaf out.
- I->setOperand(1, Context.getUndef(I->getType()));
+ I->setOperand(1, UndefValue::get(I->getType()));
}
// RewriteExprTree - Now that the operands for this expression tree are
Instruction *I = Insts.back();
Insts.pop_back();
if (!I->use_empty())
- I->replaceAllUsesWith(F.getContext().getUndef(I->getType()));
+ I->replaceAllUsesWith(UndefValue::get(I->getType()));
BB->getInstList().erase(I);
MadeChanges = true;
++NumInstRemoved;
continue;
Constant *Const = IV.isConstant()
- ? IV.getConstant() : F.getContext().getUndef(Inst->getType());
+ ? IV.getConstant() : UndefValue::get(Inst->getType());
DEBUG(errs() << " Constant: " << *Const << " = " << *Inst);
// Replaces all of the uses of a variable with uses of the constant.
LatticeVal &IV = Values[AI];
if (IV.isConstant() || IV.isUndefined()) {
Constant *CST = IV.isConstant() ?
- IV.getConstant() : Context->getUndef(AI->getType());
+ IV.getConstant() : UndefValue::get(AI->getType());
DEBUG(errs() << "*** Arg " << *AI << " = " << *CST <<"\n");
// Replaces all of the uses of a variable with uses of the
Instruction *I = Insts.back();
Insts.pop_back();
if (!I->use_empty())
- I->replaceAllUsesWith(Context->getUndef(I->getType()));
+ I->replaceAllUsesWith(UndefValue::get(I->getType()));
BB->getInstList().erase(I);
MadeChanges = true;
++IPNumInstRemoved;
TI->getSuccessor(i)->removePredecessor(BB);
}
if (!TI->use_empty())
- TI->replaceAllUsesWith(Context->getUndef(TI->getType()));
+ TI->replaceAllUsesWith(UndefValue::get(TI->getType()));
BB->getInstList().erase(TI);
if (&*BB != &F->front())
continue;
Constant *Const = IV.isConstant()
- ? IV.getConstant() : Context->getUndef(Inst->getType());
+ ? IV.getConstant() : UndefValue::get(Inst->getType());
DEBUG(errs() << " Constant: " << *Const << " = " << *Inst);
// Replaces all of the uses of a variable with uses of the
for (Function::iterator BB = F->begin(), E = F->end(); BB != E; ++BB)
if (ReturnInst *RI = dyn_cast<ReturnInst>(BB->getTerminator()))
if (!isa<UndefValue>(RI->getOperand(0)))
- RI->setOperand(0, Context->getUndef(F->getReturnType()));
+ RI->setOperand(0, UndefValue::get(F->getReturnType()));
}
// If we infered constant or undef values for globals variables, we can delete
// %insert = insertvalue { i32, i32 } %insert.0, i32 %load.1, 1
// (Also works for arrays instead of structs)
if (LoadInst *LI = dyn_cast<LoadInst>(User)) {
- Value *Insert = Context.getUndef(LI->getType());
+ Value *Insert = UndefValue::get(LI->getType());
for (unsigned i = 0, e = ElementAllocas.size(); i != e; ++i) {
Value *Load = new LoadInst(ElementAllocas[i], "load", LI);
Insert = InsertValueInst::Create(Insert, Load, i, "insert", LI);
if (FromVal->getType() == ToType && Offset == 0)
return FromVal;
- LLVMContext &Context = FromVal->getContext();
-
// If the result alloca is a vector type, this is either an element
// access or a bitcast to another vector type of the same size.
if (const VectorType *VTy = dyn_cast<VectorType>(FromVal->getType())) {
// use insertvalue's to form the FCA.
if (const StructType *ST = dyn_cast<StructType>(ToType)) {
const StructLayout &Layout = *TD->getStructLayout(ST);
- Value *Res = Context.getUndef(ST);
+ Value *Res = UndefValue::get(ST);
for (unsigned i = 0, e = ST->getNumElements(); i != e; ++i) {
Value *Elt = ConvertScalar_ExtractValue(FromVal, ST->getElementType(i),
Offset+Layout.getElementOffsetInBits(i),
if (const ArrayType *AT = dyn_cast<ArrayType>(ToType)) {
uint64_t EltSize = TD->getTypeAllocSizeInBits(AT->getElementType());
- Value *Res = Context.getUndef(AT);
+ Value *Res = UndefValue::get(AT);
for (unsigned i = 0, e = AT->getNumElements(); i != e; ++i) {
Value *Elt = ConvertScalar_ExtractValue(FromVal, AT->getElementType(),
Offset+i*EltSize, Builder);
BasicBlock::iterator BBI = I, BBE = BB->end();
while (BBI != BBE) {
if (!BBI->use_empty())
- BBI->replaceAllUsesWith(Context.getUndef(BBI->getType()));
+ BBI->replaceAllUsesWith(UndefValue::get(BBI->getType()));
BB->getInstList().erase(BBI++);
}
}
// contained within it must dominate their uses, that all uses will
// eventually be removed (they are themselves dead).
if (!I.use_empty())
- I.replaceAllUsesWith(BB->getContext().getUndef(I.getType()));
+ I.replaceAllUsesWith(UndefValue::get(I.getType()));
BB->getInstList().pop_back();
}
if (PN->getIncomingValue(0) != PN)
PN->replaceAllUsesWith(PN->getIncomingValue(0));
else
- PN->replaceAllUsesWith(BB->getContext().getUndef(PN->getType()));
+ PN->replaceAllUsesWith(UndefValue::get(PN->getType()));
PN->eraseFromParent();
}
}
if (NumPreds == 0) {
// Insert dummy values as the incoming value.
for (BasicBlock::iterator I = BB->begin(); isa<PHINode>(I); ++I)
- cast<PHINode>(I)->addIncoming(BB->getContext().getUndef(I->getType()),
- NewBB);
+ cast<PHINode>(I)->addIncoming(UndefValue::get(I->getType()), NewBB);
return NewBB;
}
BasicBlock::iterator I = NewBB->begin();
BasicBlock::const_iterator OldI = OldBB->begin();
while ((PN = dyn_cast<PHINode>(I++))) {
- Value *NV = OldFunc->getContext().getUndef(PN->getType());
+ Value *NV = UndefValue::get(PN->getType());
PN->replaceAllUsesWith(NV);
assert(ValueMap[OldI] == PN && "ValueMap mismatch");
ValueMap[OldI] = NV;
if (!TheCall->use_empty()) {
ReturnInst *R = Returns[0];
if (TheCall == R->getReturnValue())
- TheCall->replaceAllUsesWith(Context.getUndef(TheCall->getType()));
+ TheCall->replaceAllUsesWith(UndefValue::get(TheCall->getType()));
else
TheCall->replaceAllUsesWith(R->getReturnValue());
}
// using the return value of the call with the computed value.
if (!TheCall->use_empty()) {
if (TheCall == Returns[0]->getReturnValue())
- TheCall->replaceAllUsesWith(Context.getUndef(TheCall->getType()));
+ TheCall->replaceAllUsesWith(UndefValue::get(TheCall->getType()));
else
TheCall->replaceAllUsesWith(Returns[0]->getReturnValue());
}
} else if (!TheCall->use_empty()) {
// No returns, but something is using the return value of the call. Just
// nuke the result.
- TheCall->replaceAllUsesWith(Context.getUndef(TheCall->getType()));
+ TheCall->replaceAllUsesWith(UndefValue::get(TheCall->getType()));
}
// Since we are now done with the Call/Invoke, we can delete it.
DenseMap<DomTreeNode*, Value*> &Phis) {
// If there is no dominator info for this BB, it is unreachable.
if (BB == 0)
- return OrigInst->getContext().getUndef(OrigInst->getType());
+ return UndefValue::get(OrigInst->getType());
// If we have already computed this value, return the previously computed val.
if (Phis.count(BB)) return Phis[BB];
/// too, recursively.
void
llvm::RecursivelyDeleteDeadPHINode(PHINode *PN) {
- LLVMContext &Context = PN->getContext();
-
// We can remove a PHI if it is on a cycle in the def-use graph
// where each node in the cycle has degree one, i.e. only one use,
// and is an instruction with no side effects.
if (PHINode *JP = dyn_cast<PHINode>(J))
if (!PHIs.insert(cast<PHINode>(JP))) {
// Break the cycle and delete the PHI and its operands.
- JP->replaceAllUsesWith(Context.getUndef(JP->getType()));
+ JP->replaceAllUsesWith(UndefValue::get(JP->getType()));
RecursivelyDeleteTriviallyDeadInstructions(JP);
break;
}
while (PHINode *PN = dyn_cast<PHINode>(DestBB->begin())) {
Value *NewVal = PN->getIncomingValue(0);
// Replace self referencing PHI with undef, it must be dead.
- if (NewVal == PN) NewVal = DestBB->getContext().getUndef(PN->getType());
+ if (NewVal == PN) NewVal = UndefValue::get(PN->getType());
PN->replaceAllUsesWith(NewVal);
PN->eraseFromParent();
}
// Delete the dead terminator.
if (AA) AA->deleteValue(TI);
if (!TI->use_empty())
- TI->replaceAllUsesWith(F.getContext().getUndef(TI->getType()));
+ TI->replaceAllUsesWith(UndefValue::get(TI->getType()));
TI->eraseFromParent();
Changed |= true;
}
//
RenamePassData::ValVector Values(Allocas.size());
for (unsigned i = 0, e = Allocas.size(); i != e; ++i)
- Values[i] = Context.getUndef(Allocas[i]->getAllocatedType());
+ Values[i] = UndefValue::get(Allocas[i]->getAllocatedType());
// Walks all basic blocks in the function performing the SSA rename algorithm
// and inserting the phi nodes we marked as necessary
// Just delete the users now.
//
if (!A->use_empty())
- A->replaceAllUsesWith(Context.getUndef(A->getType()));
+ A->replaceAllUsesWith(UndefValue::get(A->getType()));
if (AST) AST->deleteValue(A);
A->eraseFromParent();
}
BasicBlock::iterator BBI = BB->begin();
while ((SomePHI = dyn_cast<PHINode>(BBI++)) &&
SomePHI->getNumIncomingValues() == NumBadPreds) {
- Value *UndefVal = Context.getUndef(SomePHI->getType());
+ Value *UndefVal = UndefValue::get(SomePHI->getType());
for (unsigned pred = 0, e = Preds.size(); pred != e; ++pred)
SomePHI->addIncoming(UndefVal, Preds[pred]);
}
if (StoresByIndex.empty()) {
for (Value::use_iterator UI = AI->use_begin(), E = AI->use_end(); UI != E;)
if (LoadInst *LI = dyn_cast<LoadInst>(*UI++)) {
- LI->replaceAllUsesWith(Context.getUndef(LI->getType()));
+ LI->replaceAllUsesWith(UndefValue::get(LI->getType()));
if (AST && isa<PointerType>(LI->getType()))
AST->deleteValue(LI);
LBI.deleteValue(LI);
/// FoldTwoEntryPHINode - Given a BB that starts with the specified two-entry
/// PHI node, see if we can eliminate it.
static bool FoldTwoEntryPHINode(PHINode *PN) {
- LLVMContext &Context = PN->getParent()->getContext();
-
// Ok, this is a two entry PHI node. Check to see if this is a simple "if
// statement", which has a very simple dominance structure. Basically, we
// are trying to find the condition that is being branched on, which
if (PN->getIncomingValue(0) != PN)
PN->replaceAllUsesWith(PN->getIncomingValue(0));
else
- PN->replaceAllUsesWith(Context.getUndef(PN->getType()));
+ PN->replaceAllUsesWith(UndefValue::get(PN->getType()));
} else if (!DominatesMergePoint(PN->getIncomingValue(0), BB,
&AggressiveInsts) ||
!DominatesMergePoint(PN->getIncomingValue(1), BB,
// order to seamlessly integrate with existing context.
void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) {
Function *F = CI->getCalledFunction();
- LLVMContext &Context = F->getContext();
assert(F && "CallInst has no function associated with it.");
Value *Op0 = CI->getOperand(1);
ShuffleVectorInst *SI = NULL;
if (isLoadH || isLoadL) {
- Value *Op1 = Context.getUndef(Op0->getType());
+ Value *Op1 = UndefValue::get(Op0->getType());
Value *Addr = new BitCastInst(CI->getOperand(2),
PointerType::getUnqual(Type::DoubleTy),
"upgraded.", CI);
PN->replaceAllUsesWith(PN->getOperand(0));
else
// We are left with an infinite loop with no entries: kill the PHI.
- PN->replaceAllUsesWith(getContext().getUndef(PN->getType()));
+ PN->replaceAllUsesWith(UndefValue::get(PN->getType()));
getInstList().pop_front(); // Remove the PHI node
}
// Finally, implement bitcast folding now. The code below doesn't handle
// bitcast right.
if (isa<ConstantPointerNull>(V)) // ptr->ptr cast.
- return Con
text.getConstantPointerNull(cast<PointerType>(DestTy));
+ return Con
stantPointerNull::get(cast<PointerType>(DestTy));
// Handle integral constant input.
if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
if (opc == Instruction::ZExt || opc == Instruction::SExt ||
opc == Instruction::UIToFP || opc == Instruction::SIToFP)
return Context.getNullValue(DestTy);
- return Context.getUndef(DestTy);
+ return UndefValue::get(DestTy);
}
// No compile-time operations on this type yet.
if (V->getType() == Type::PPC_FP128Ty || DestTy == Type::PPC_FP128Ty)
return 0; // Can't fold.
case Instruction::IntToPtr: //always treated as unsigned
if (V->isNullValue()) // Is it an integral null value?
- return Con
text.getConstantPointerNull(cast<PointerType>(DestTy));
+ return Con
stantPointerNull::get(cast<PointerType>(DestTy));
return 0; // Other pointer types cannot be casted
case Instruction::PtrToInt: // always treated as unsigned
if (V->isNullValue()) // is it a null pointer value?
const Constant *Val,
const Constant *Idx) {
if (isa<UndefValue>(Val)) // ee(undef, x) -> undef
- return Context.getUndef(cast<VectorType>(Val->getType())->getElementType());
+ return UndefValue::get(cast<VectorType>(Val->getType())->getElementType());
if (Val->isNullValue()) // ee(zero, x) -> zero
return Context.getNullValue(
cast<VectorType>(Val->getType())->getElementType());
Ops.reserve(numOps);
for (unsigned i = 0; i < numOps; ++i) {
const Constant *Op =
- (idxVal == i) ? Elt : Context.getUndef(Elt->getType());
+ (idxVal == i) ? Elt : UndefValue::get(Elt->getType());
Ops.push_back(const_cast<Constant*>(Op));
}
return ConstantVector::get(Ops);
if (isa<ConstantAggregateZero>(C))
return Context.getNullValue(EltTy);
if (isa<UndefValue>(C))
- return Context.getUndef(EltTy);
+ return UndefValue::get(EltTy);
return 0;
}
const Constant *V2,
const Constant *Mask) {
// Undefined shuffle mask -> undefined value.
- if (isa<UndefValue>(Mask)) return Context.getUndef(V1->getType());
+ if (isa<UndefValue>(Mask)) return UndefValue::get(V1->getType());
unsigned MaskNumElts = cast<VectorType>(Mask->getType())->getNumElements();
unsigned SrcNumElts = cast<VectorType>(V1->getType())->getNumElements();
if (InElt == 0) return 0;
if (isa<UndefValue>(InElt))
- InElt = Context.getUndef(EltTy);
+ InElt = UndefValue::get(EltTy);
else if (ConstantInt *CI = dyn_cast<ConstantInt>(InElt)) {
unsigned Elt = CI->getZExtValue();
if (Elt >= SrcNumElts*2)
- InElt = Context.getUndef(EltTy);
+ InElt = UndefValue::get(EltTy);
else if (Elt >= SrcNumElts)
InElt = GetVectorElement(Context, V2, Elt - SrcNumElts);
else
return const_cast<Constant *>(Agg);
if (isa<UndefValue>(Agg)) // ev(undef, x) -> undef
- return Context.getUndef(ExtractValueInst::getIndexedType(Agg->getType(),
+ return UndefValue::get(ExtractValueInst::getIndexedType(Agg->getType(),
Idxs,
Idxs + NumIdx));
const Type *MemberTy = AggTy->getTypeAtIndex(i);
const Constant *Op =
(*Idxs == i) ?
- ConstantFoldInsertValueInstruction(Context, Context.getUndef(MemberTy),
+ ConstantFoldInsertValueInstruction(Context, UndefValue::get(MemberTy),
Val, Idxs+1, NumIdx-1) :
- Context.getUndef(MemberTy);
+ UndefValue::get(MemberTy);
Ops[i] = const_cast<Constant*>(Op);
}
if (isa<StructType>(AggTy))
// Fallthrough
case Instruction::Add:
case Instruction::Sub:
- return Context.getUndef(C1->getType());
+ return UndefValue::get(C1->getType());
case Instruction::Mul:
case Instruction::And:
return Context.getNullValue(C1->getType());
if (CI2->equalsInt(1))
return const_cast<Constant*>(C1); // X / 1 == X
if (CI2->equalsInt(0))
- return Context.getUndef(CI2->getType()); // X / 0 == undef
+ return UndefValue::get(CI2->getType()); // X / 0 == undef
break;
case Instruction::URem:
case Instruction::SRem:
if (CI2->equalsInt(1))
return Context.getNullValue(CI2->getType()); // X % 1 == 0
if (CI2->equalsInt(0))
- return Context.getUndef(CI2->getType()); // X % 0 == undef
+ return UndefValue::get(CI2->getType()); // X % 0 == undef
break;
case Instruction::And:
if (CI2->isZero()) return const_cast<Constant*>(C2); // X & 0 == 0
case Instruction::SDiv:
assert(!CI2->isNullValue() && "Div by zero handled above");
if (C2V.isAllOnesValue() && C1V.isMinSignedValue())
- return Context.getUndef(CI1->getType()); // MIN_INT / -1 -> undef
+ return UndefValue::get(CI1->getType()); // MIN_INT / -1 -> undef
return ConstantInt::get(Context, C1V.sdiv(C2V));
case Instruction::URem:
assert(!CI2->isNullValue() && "Div by zero handled above");
case Instruction::SRem:
assert(!CI2->isNullValue() && "Div by zero handled above");
if (C2V.isAllOnesValue() && C1V.isMinSignedValue())
- return Context.getUndef(CI1->getType()); // MIN_INT % -1 -> undef
+ return UndefValue::get(CI1->getType()); // MIN_INT % -1 -> undef
return ConstantInt::get(Context, C1V.srem(C2V));
case Instruction::And:
return ConstantInt::get(Context, C1V & C2V);
if (shiftAmt < C1V.getBitWidth())
return ConstantInt::get(Context, C1V.shl(shiftAmt));
else
- return Context.getUndef(C1->getType()); // too big shift is undef
+ return UndefValue::get(C1->getType()); // too big shift is undef
}
case Instruction::LShr: {
uint32_t shiftAmt = C2V.getZExtValue();
if (shiftAmt < C1V.getBitWidth())
return ConstantInt::get(Context, C1V.lshr(shiftAmt));
else
- return Context.getUndef(C1->getType()); // too big shift is undef
+ return UndefValue::get(C1->getType()); // too big shift is undef
}
case Instruction::AShr: {
uint32_t shiftAmt = C2V.getZExtValue();
if (shiftAmt < C1V.getBitWidth())
return ConstantInt::get(Context, C1V.ashr(shiftAmt));
else
- return Context.getUndef(C1->getType()); // too big shift is undef
+ return UndefValue::get(C1->getType()); // too big shift is undef
}
}
}
// Handle some degenerate cases first
if (isa<UndefValue>(C1) || isa<UndefValue>(C2))
- return Context.getUndef(ResultTy);
+ return UndefValue::get(ResultTy);
// No compile-time operations on this type yet.
if (C1->getType() == Type::PPC_FP128Ty)
(Value **)Idxs,
(Value **)Idxs+NumIdx);
assert(Ty != 0 && "Invalid indices for GEP!");
- return Context.getUndef(PointerType::get(Ty, Ptr->getAddressSpace()));
+ return UndefValue::get(PointerType::get(Ty, Ptr->getAddressSpace()));
}
Constant *Idx0 = Idxs[0];
(Value**)Idxs,
(Value**)Idxs+NumIdx);
assert(Ty != 0 && "Invalid indices for GEP!");
- return Context.getConstantPointerNull(
+ return ConstantPointerNull::get(
PointerType::get(Ty,Ptr->getAddressSpace()));
}
}
}
if (isa<UndefValue>(this)) {
- Elts.assign(VT->getNumElements(), Context.getUndef(VT->getElementType()));
+ Elts.assign(VT->getNumElements(), UndefValue::get(VT->getElementType()));
return;
}
}
}
- return Ty->getContext().getConstantAggregateZero(Ty);
+ return ConstantAggregateZero::get(Ty);
}
// Implicitly locked.
return pImpl->StructConstants.getOrCreate(T, V);
- return T->getContext().getConstantAggregateZero(T);
+ return ConstantAggregateZero::get(T);
}
Constant* ConstantStruct::get(const std::vector<Constant*>& V, bool packed) {
}
if (isZero)
- return Context.getConstantAggregateZero(T);
+ return ConstantAggregateZero::get(T);
if (isUndef)
- return Context.getUndef(T);
+ return UndefValue::get(T);
// Implicitly locked.
return pImpl->VectorConstants.getOrCreate(T, V);
//===----------------------------------------------------------------------===//
// Factory Function Implementation
+static char getValType(ConstantAggregateZero *CPZ) { return 0; }
+
+ConstantAggregateZero* ConstantAggregateZero::get(const Type* Ty) {
+ assert((isa<StructType>(Ty) || isa<ArrayType>(Ty) || isa<VectorType>(Ty)) &&
+ "Cannot create an aggregate zero of non-aggregate type!");
+
+ LLVMContextImpl *pImpl = Ty->getContext().pImpl;
+ // Implicitly locked.
+ return pImpl->AggZeroConstants.getOrCreate(Ty, 0);
+}
+
/// destroyConstant - Remove the constant from the constant table...
///
void ConstantAggregateZero::destroyConstant() {
// Implicitly locked.
- getType()->getContext().erase(this);
+ getType()->getContext().pImpl->AggZeroConstants.remove(this);
destroyConstantImpl();
}
Constant *Replacement = 0;
if (isAllZeros) {
- Replacement = Context.getConstantAggregateZero(getType());
+ Replacement = ConstantAggregateZero::get(getType());
} else {
// Check to see if we have this array type already.
sys::SmartScopedWriter<true> Writer(pImpl->ConstantsLock);
Constant *Replacement = 0;
if (isAllZeros) {
- Replacement = Context.getConstantAggregateZero(getType());
+ Replacement = ConstantAggregateZero::get(getType());
} else {
// Check to see if we have this array type already.
sys::SmartScopedWriter<true> Writer(pImpl->ConstantsLock);
}
LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty) {
- return wrap(getGlobalContext().getUndef(unwrap(Ty)));
+ return wrap(UndefValue::get(unwrap(Ty)));
}
int LLVMIsConstant(LLVMValueRef Ty) {
LLVMValueRef LLVMConstPointerNull(LLVMTypeRef Ty) {
return
- wrap(
getGlobalContext().getConstantPointerNull(unwrap<PointerType>(Ty)));
+ wrap(
ConstantPointerNull::get(unwrap<PointerType>(Ty)));
}
/*--.. Operations on scalar constants ......................................--*/
// If the PHI node is dead, because it has zero entries, nuke it now.
if (NumOps == 2 && DeletePHIIfEmpty) {
// If anyone is using this PHI, make them use a dummy value instead...
- replaceAllUsesWith(getType()->getContext().getUndef(getType()));
+ replaceAllUsesWith(UndefValue::get(getType()));
eraseFromParent();
}
return Removed;
if (getIncomingValue(0) != this) // not X = phi X
return getIncomingValue(0);
else
- return
- getType()->getContext().getUndef(getType()); // Self cycle is dead.
+ return UndefValue::get(getType()); // Self cycle is dead.
}
// Otherwise if all of the incoming values are the same for the PHI, replace
// that only has entries for itself. In this case, there is no entry into the
// loop, so kill the PHI.
//
- if (InVal == 0) InVal = getType()->getContext().getUndef(getType());
+ if (InVal == 0) InVal = UndefValue::get(getType());
// If we have a PHI node like phi(X, undef, X), where X is defined by some
// instruction, we cannot always return X as the result of the PHI node. Only
case Type::PPC_FP128TyID:
return ConstantFP::get(Ty->getContext(), APFloat(APInt(128, 2, zero)));
case Type::PointerTyID:
- return
getConstantPointerNull(cast<PointerType>(Ty));
+ return
ConstantPointerNull::get(cast<PointerType>(Ty));
case Type::StructTyID:
case Type::ArrayTyID:
case Type::VectorTyID:
- return getConstantAggregateZero(Ty);
+ return ConstantAggregateZero::get(Ty);
default:
// Function, Label, or Opaque type?
assert(!"Cannot create a null constant of that type!");
return cast<ConstantVector>(ConstantVector::get(Elts));
}
-// UndefValue accessors.
-UndefValue* LLVMContext::getUndef(const Type* Ty) {
- return UndefValue::get(Ty);
-}
-
// ConstantInt accessors.
ConstantInt* LLVMContext::getTrue() {
assert(this && "Context not initialized!");
return pImpl->getFalse();
}
-// ConstantPointerNull accessors.
-ConstantPointerNull* LLVMContext::getConstantPointerNull(const PointerType* T) {
- return ConstantPointerNull::get(T);
-}
-
-// ConstantAggregateZero accessors.
-ConstantAggregateZero* LLVMContext::getConstantAggregateZero(const Type* Ty) {
- return pImpl->getConstantAggregateZero(Ty);
-}
-
// MDNode accessors
MDNode* LLVMContext::getMDNode(Value* const* Vals, unsigned NumVals) {
return pImpl->getMDNode(Vals, NumVals);
void LLVMContext::erase(MDNode *M) {
pImpl->erase(M);
}
-
-void LLVMContext::erase(ConstantAggregateZero *Z) {
- pImpl->erase(Z);
-}
#include "llvm/Metadata.h"
using namespace llvm;
-static char getValType(ConstantAggregateZero *CPZ) { return 0; }
-
LLVMContextImpl::LLVMContextImpl(LLVMContext &C) :
Context(C), TheTrueVal(0), TheFalseVal(0) { }
return N;
}
-ConstantAggregateZero*
-LLVMContextImpl::getConstantAggregateZero(const Type *Ty) {
- assert((isa<StructType>(Ty) || isa<ArrayType>(Ty) || isa<VectorType>(Ty)) &&
- "Cannot create an aggregate zero of non-aggregate type!");
-
- // Implicitly locked.
- return AggZeroConstants.getOrCreate(Ty, 0);
-}
-
// *** erase methods ***
void LLVMContextImpl::erase(MDString *M) {
sys::SmartScopedWriter<true> Writer(ConstantsLock);
MDNodeSet.RemoveNode(M);
}
-
-void LLVMContextImpl::erase(ConstantAggregateZero *Z) {
- AggZeroConstants.remove(Z);
-}
struct ConvertConstantType<ConstantAggregateZero, Type> {
static void convert(ConstantAggregateZero *OldC, const Type *NewTy) {
// Make everyone now use a constant of the new type...
- Constant *New = NewTy->getContext().getConstantAggregateZero(NewTy);
+ Constant *New = ConstantAggregateZero::get(NewTy);
assert(New != OldC && "Didn't replace constant??");
OldC->uncheckedReplaceAllUsesWith(New);
OldC->destroyConstant(); // This constant is now dead, destroy it.
friend class ConstantStruct;
friend class ConstantArray;
friend class ConstantVector;
+ friend class ConstantAggregateZero;
public:
LLVMContextImpl(LLVMContext &C);
MDNode *getMDNode(Value*const* Vals, unsigned NumVals);
- ConstantAggregateZero *getConstantAggregateZero(const Type *Ty);
-
ConstantInt *getTrue() {
if (TheTrueVal)
return TheTrueVal;
void erase(MDString *M);
void erase(MDNode *M);
- void erase(ConstantAggregateZero *Z);
};
}
// If this instruction produces a value, replace any users with null values
if (isa<StructType>(TheInst->getType()))
- TheInst->replaceAllUsesWith(Context.getUndef(TheInst->getType()));
+ TheInst->replaceAllUsesWith(UndefValue::get(TheInst->getType()));
else if (TheInst->getType() != Type::VoidTy)
TheInst->replaceAllUsesWith(Context.getNullValue(TheInst->getType()));
// function that dynamically resolves the calls to F via our JIT API
if (!F->use_empty()) {
// Create a new global to hold the cached function pointer.
- Constant *NullPtr = Context.getConstantPointerNull(F->getType());
+ Constant *NullPtr = ConstantPointerNull::get(F->getType());
GlobalVariable *Cache =
new GlobalVariable(*F->getParent(), F->getType(),
false, GlobalValue::InternalLinkage,
Constant* Zero = ConstantInt::get(Int1, 0);
Constant* NegOne = ConstantInt::get(Int1, static_cast<uint64_t>(-1), true);
EXPECT_EQ(NegOne, ConstantInt::getSigned(Int1, -1));
- Constant* Undef = getGlobalContext().getUndef(Int1);
+ Constant* Undef = UndefValue::get(Int1);
// Input: @b = constant i1 add(i1 1 , i1 1)
// Output: @b = constant i1 false
projects / oota-llvm.git / commitdiff