mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-10-19 02:52:53 +02:00
Move more code back to 2.5 APIs.
llvm-svn: 77635
This commit is contained in:
parent
7f2d10ec49
commit
93ccaf5c60
@ -305,6 +305,8 @@ protected:
|
|||||||
return User::operator new(s, 0);
|
return User::operator new(s, 0);
|
||||||
}
|
}
|
||||||
public:
|
public:
|
||||||
|
static ConstantAggregateZero* get(const Type* Ty);
|
||||||
|
|
||||||
/// isNullValue - Return true if this is the value that would be returned by
|
/// isNullValue - Return true if this is the value that would be returned by
|
||||||
/// getNullValue.
|
/// getNullValue.
|
||||||
virtual bool isNullValue() const { return true; }
|
virtual bool isNullValue() const { return true; }
|
||||||
|
@ -60,6 +60,7 @@ class LLVMContext {
|
|||||||
friend class ConstantStruct;
|
friend class ConstantStruct;
|
||||||
friend class ConstantArray;
|
friend class ConstantArray;
|
||||||
friend class ConstantVector;
|
friend class ConstantVector;
|
||||||
|
friend class ConstantAggregateZero;
|
||||||
public:
|
public:
|
||||||
LLVMContext();
|
LLVMContext();
|
||||||
~LLVMContext();
|
~LLVMContext();
|
||||||
@ -72,19 +73,10 @@ public:
|
|||||||
/// @brief Get the all ones value
|
/// @brief Get the all ones value
|
||||||
Constant* getAllOnesValue(const Type* Ty);
|
Constant* getAllOnesValue(const Type* Ty);
|
||||||
|
|
||||||
// UndefValue accessors
|
|
||||||
UndefValue* getUndef(const Type* Ty);
|
|
||||||
|
|
||||||
// ConstantInt accessors
|
// ConstantInt accessors
|
||||||
ConstantInt* getTrue();
|
ConstantInt* getTrue();
|
||||||
ConstantInt* getFalse();
|
ConstantInt* getFalse();
|
||||||
|
|
||||||
// ConstantPointerNull accessors
|
|
||||||
ConstantPointerNull* getConstantPointerNull(const PointerType* T);
|
|
||||||
|
|
||||||
// ConstantAggregateZero accessors
|
|
||||||
ConstantAggregateZero* getConstantAggregateZero(const Type* Ty);
|
|
||||||
|
|
||||||
// MDNode accessors
|
// MDNode accessors
|
||||||
MDNode* getMDNode(Value* const* Vals, unsigned NumVals);
|
MDNode* getMDNode(Value* const* Vals, unsigned NumVals);
|
||||||
|
|
||||||
@ -95,7 +87,6 @@ public:
|
|||||||
// Methods for erasing constants
|
// Methods for erasing constants
|
||||||
void erase(MDString *M);
|
void erase(MDString *M);
|
||||||
void erase(MDNode *M);
|
void erase(MDNode *M);
|
||||||
void erase(ConstantAggregateZero *Z);
|
|
||||||
};
|
};
|
||||||
|
|
||||||
/// FOR BACKWARDS COMPATIBILITY - Returns a global context.
|
/// FOR BACKWARDS COMPATIBILITY - Returns a global context.
|
||||||
|
@ -146,7 +146,7 @@ public:
|
|||||||
///
|
///
|
||||||
ReturnInst *CreateAggregateRet(Value * const* retVals, unsigned N) {
|
ReturnInst *CreateAggregateRet(Value * const* retVals, unsigned N) {
|
||||||
const Type *RetType = BB->getParent()->getReturnType();
|
const Type *RetType = BB->getParent()->getReturnType();
|
||||||
Value *V = Context.getUndef(RetType);
|
Value *V = UndefValue::get(RetType);
|
||||||
for (unsigned i = 0; i != N; ++i)
|
for (unsigned i = 0; i != N; ++i)
|
||||||
V = CreateInsertValue(V, retVals[i], i, "mrv");
|
V = CreateInsertValue(V, retVals[i], i, "mrv");
|
||||||
return Insert(ReturnInst::Create(V));
|
return Insert(ReturnInst::Create(V));
|
||||||
|
@ -286,7 +286,7 @@ Constant *llvm::ConstantFoldInstruction(Instruction *I, LLVMContext &Context,
|
|||||||
const TargetData *TD) {
|
const TargetData *TD) {
|
||||||
if (PHINode *PN = dyn_cast<PHINode>(I)) {
|
if (PHINode *PN = dyn_cast<PHINode>(I)) {
|
||||||
if (PN->getNumIncomingValues() == 0)
|
if (PN->getNumIncomingValues() == 0)
|
||||||
return Context.getUndef(PN->getType());
|
return UndefValue::get(PN->getType());
|
||||||
|
|
||||||
Constant *Result = dyn_cast<Constant>(PN->getIncomingValue(0));
|
Constant *Result = dyn_cast<Constant>(PN->getIncomingValue(0));
|
||||||
if (Result == 0) return 0;
|
if (Result == 0) return 0;
|
||||||
@ -560,7 +560,7 @@ Constant *llvm::ConstantFoldLoadThroughGEPConstantExpr(Constant *C,
|
|||||||
} else if (isa<ConstantAggregateZero>(C)) {
|
} else if (isa<ConstantAggregateZero>(C)) {
|
||||||
C = Context.getNullValue(STy->getElementType(El));
|
C = Context.getNullValue(STy->getElementType(El));
|
||||||
} else if (isa<UndefValue>(C)) {
|
} else if (isa<UndefValue>(C)) {
|
||||||
C = Context.getUndef(STy->getElementType(El));
|
C = UndefValue::get(STy->getElementType(El));
|
||||||
} else {
|
} else {
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
@ -573,7 +573,7 @@ Constant *llvm::ConstantFoldLoadThroughGEPConstantExpr(Constant *C,
|
|||||||
else if (isa<ConstantAggregateZero>(C))
|
else if (isa<ConstantAggregateZero>(C))
|
||||||
C = Context.getNullValue(ATy->getElementType());
|
C = Context.getNullValue(ATy->getElementType());
|
||||||
else if (isa<UndefValue>(C))
|
else if (isa<UndefValue>(C))
|
||||||
C = Context.getUndef(ATy->getElementType());
|
C = UndefValue::get(ATy->getElementType());
|
||||||
else
|
else
|
||||||
return 0;
|
return 0;
|
||||||
} else if (const VectorType *PTy = dyn_cast<VectorType>(*I)) {
|
} else if (const VectorType *PTy = dyn_cast<VectorType>(*I)) {
|
||||||
@ -584,7 +584,7 @@ Constant *llvm::ConstantFoldLoadThroughGEPConstantExpr(Constant *C,
|
|||||||
else if (isa<ConstantAggregateZero>(C))
|
else if (isa<ConstantAggregateZero>(C))
|
||||||
C = Context.getNullValue(PTy->getElementType());
|
C = Context.getNullValue(PTy->getElementType());
|
||||||
else if (isa<UndefValue>(C))
|
else if (isa<UndefValue>(C))
|
||||||
C = Context.getUndef(PTy->getElementType());
|
C = UndefValue::get(PTy->getElementType());
|
||||||
else
|
else
|
||||||
return 0;
|
return 0;
|
||||||
} else {
|
} else {
|
||||||
|
@ -497,7 +497,7 @@ Constant *DIFactory::GetStringConstant(const std::string &String) {
|
|||||||
|
|
||||||
// If empty string then use a i8* null instead.
|
// If empty string then use a i8* null instead.
|
||||||
if (String.empty())
|
if (String.empty())
|
||||||
return Slot = VMContext.getConstantPointerNull(DestTy);
|
return Slot = ConstantPointerNull::get(DestTy);
|
||||||
|
|
||||||
// Construct string as an llvm constant.
|
// Construct string as an llvm constant.
|
||||||
Constant *ConstStr = ConstantArray::get(String);
|
Constant *ConstStr = ConstantArray::get(String);
|
||||||
|
@ -884,7 +884,7 @@ Value *BuildSubAggregate(Value *From, const unsigned *idx_begin,
|
|||||||
const Type *IndexedType = ExtractValueInst::getIndexedType(From->getType(),
|
const Type *IndexedType = ExtractValueInst::getIndexedType(From->getType(),
|
||||||
idx_begin,
|
idx_begin,
|
||||||
idx_end);
|
idx_end);
|
||||||
Value *To = Context.getUndef(IndexedType);
|
Value *To = UndefValue::get(IndexedType);
|
||||||
SmallVector<unsigned, 10> Idxs(idx_begin, idx_end);
|
SmallVector<unsigned, 10> Idxs(idx_begin, idx_end);
|
||||||
unsigned IdxSkip = Idxs.size();
|
unsigned IdxSkip = Idxs.size();
|
||||||
|
|
||||||
@ -913,7 +913,7 @@ Value *llvm::FindInsertedValue(Value *V, const unsigned *idx_begin,
|
|||||||
const CompositeType *PTy = cast<CompositeType>(V->getType());
|
const CompositeType *PTy = cast<CompositeType>(V->getType());
|
||||||
|
|
||||||
if (isa<UndefValue>(V))
|
if (isa<UndefValue>(V))
|
||||||
return Context.getUndef(ExtractValueInst::getIndexedType(PTy,
|
return UndefValue::get(ExtractValueInst::getIndexedType(PTy,
|
||||||
idx_begin,
|
idx_begin,
|
||||||
idx_end));
|
idx_end));
|
||||||
else if (isa<ConstantAggregateZero>(V))
|
else if (isa<ConstantAggregateZero>(V))
|
||||||
|
@ -1481,7 +1481,7 @@ LLParser::PerFunctionState::~PerFunctionState() {
|
|||||||
I = ForwardRefVals.begin(), E = ForwardRefVals.end(); I != E; ++I)
|
I = ForwardRefVals.begin(), E = ForwardRefVals.end(); I != E; ++I)
|
||||||
if (!isa<BasicBlock>(I->second.first)) {
|
if (!isa<BasicBlock>(I->second.first)) {
|
||||||
I->second.first->replaceAllUsesWith(
|
I->second.first->replaceAllUsesWith(
|
||||||
P.getContext().getUndef(I->second.first->getType()));
|
UndefValue::get(I->second.first->getType()));
|
||||||
delete I->second.first;
|
delete I->second.first;
|
||||||
I->second.first = 0;
|
I->second.first = 0;
|
||||||
}
|
}
|
||||||
@ -1490,7 +1490,7 @@ LLParser::PerFunctionState::~PerFunctionState() {
|
|||||||
I = ForwardRefValIDs.begin(), E = ForwardRefValIDs.end(); I != E; ++I)
|
I = ForwardRefValIDs.begin(), E = ForwardRefValIDs.end(); I != E; ++I)
|
||||||
if (!isa<BasicBlock>(I->second.first)) {
|
if (!isa<BasicBlock>(I->second.first)) {
|
||||||
I->second.first->replaceAllUsesWith(
|
I->second.first->replaceAllUsesWith(
|
||||||
P.getContext().getUndef(I->second.first->getType()));
|
UndefValue::get(I->second.first->getType()));
|
||||||
delete I->second.first;
|
delete I->second.first;
|
||||||
I->second.first = 0;
|
I->second.first = 0;
|
||||||
}
|
}
|
||||||
@ -2193,19 +2193,19 @@ bool LLParser::ConvertGlobalValIDToValue(const Type *Ty, ValID &ID,
|
|||||||
case ValID::t_Null:
|
case ValID::t_Null:
|
||||||
if (!isa<PointerType>(Ty))
|
if (!isa<PointerType>(Ty))
|
||||||
return Error(ID.Loc, "null must be a pointer type");
|
return Error(ID.Loc, "null must be a pointer type");
|
||||||
V = Context.getConstantPointerNull(cast<PointerType>(Ty));
|
V = ConstantPointerNull::get(cast<PointerType>(Ty));
|
||||||
return false;
|
return false;
|
||||||
case ValID::t_Undef:
|
case ValID::t_Undef:
|
||||||
// FIXME: LabelTy should not be a first-class type.
|
// FIXME: LabelTy should not be a first-class type.
|
||||||
if ((!Ty->isFirstClassType() || Ty == Type::LabelTy) &&
|
if ((!Ty->isFirstClassType() || Ty == Type::LabelTy) &&
|
||||||
!isa<OpaqueType>(Ty))
|
!isa<OpaqueType>(Ty))
|
||||||
return Error(ID.Loc, "invalid type for undef constant");
|
return Error(ID.Loc, "invalid type for undef constant");
|
||||||
V = Context.getUndef(Ty);
|
V = UndefValue::get(Ty);
|
||||||
return false;
|
return false;
|
||||||
case ValID::t_EmptyArray:
|
case ValID::t_EmptyArray:
|
||||||
if (!isa<ArrayType>(Ty) || cast<ArrayType>(Ty)->getNumElements() != 0)
|
if (!isa<ArrayType>(Ty) || cast<ArrayType>(Ty)->getNumElements() != 0)
|
||||||
return Error(ID.Loc, "invalid empty array initializer");
|
return Error(ID.Loc, "invalid empty array initializer");
|
||||||
V = Context.getUndef(Ty);
|
V = UndefValue::get(Ty);
|
||||||
return false;
|
return false;
|
||||||
case ValID::t_Zero:
|
case ValID::t_Zero:
|
||||||
// FIXME: LabelTy should not be a first-class type.
|
// FIXME: LabelTy should not be a first-class type.
|
||||||
@ -2764,7 +2764,7 @@ bool LLParser::ParseRet(Instruction *&Inst, BasicBlock *BB,
|
|||||||
RVs.push_back(RV);
|
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) {
|
for (unsigned i = 0, e = RVs.size(); i != e; ++i) {
|
||||||
Instruction *I = InsertValueInst::Create(RV, RVs[i], i, "mrv");
|
Instruction *I = InsertValueInst::Create(RV, RVs[i], i, "mrv");
|
||||||
BB->getInstList().push_back(I);
|
BB->getInstList().push_back(I);
|
||||||
|
@ -142,7 +142,7 @@ namespace {
|
|||||||
}
|
}
|
||||||
explicit ConstantPlaceHolder(const Type *Ty, LLVMContext& Context)
|
explicit ConstantPlaceHolder(const Type *Ty, LLVMContext& Context)
|
||||||
: ConstantExpr(Ty, Instruction::UserOp1, &Op<0>(), 1) {
|
: 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.
|
/// @brief Methods to support type inquiry through isa, cast, and dyn_cast.
|
||||||
@ -888,7 +888,7 @@ bool BitcodeReader::ParseConstants() {
|
|||||||
switch (BitCode) {
|
switch (BitCode) {
|
||||||
default: // Default behavior: unknown constant
|
default: // Default behavior: unknown constant
|
||||||
case bitc::CST_CODE_UNDEF: // UNDEF
|
case bitc::CST_CODE_UNDEF: // UNDEF
|
||||||
V = Context.getUndef(CurTy);
|
V = UndefValue::get(CurTy);
|
||||||
break;
|
break;
|
||||||
case bitc::CST_CODE_SETTYPE: // SETTYPE: [typeid]
|
case bitc::CST_CODE_SETTYPE: // SETTYPE: [typeid]
|
||||||
if (Record.empty())
|
if (Record.empty())
|
||||||
@ -937,7 +937,7 @@ bool BitcodeReader::ParseConstants() {
|
|||||||
else if (CurTy == Type::PPC_FP128Ty)
|
else if (CurTy == Type::PPC_FP128Ty)
|
||||||
V = ConstantFP::get(Context, APFloat(APInt(128, 2, &Record[0])));
|
V = ConstantFP::get(Context, APFloat(APInt(128, 2, &Record[0])));
|
||||||
else
|
else
|
||||||
V = Context.getUndef(CurTy);
|
V = UndefValue::get(CurTy);
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -964,7 +964,7 @@ bool BitcodeReader::ParseConstants() {
|
|||||||
Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy));
|
Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy));
|
||||||
V = ConstantVector::get(Elts);
|
V = ConstantVector::get(Elts);
|
||||||
} else {
|
} else {
|
||||||
V = Context.getUndef(CurTy);
|
V = UndefValue::get(CurTy);
|
||||||
}
|
}
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
@ -1001,7 +1001,7 @@ bool BitcodeReader::ParseConstants() {
|
|||||||
if (Record.size() < 3) return Error("Invalid CE_BINOP record");
|
if (Record.size() < 3) return Error("Invalid CE_BINOP record");
|
||||||
int Opc = GetDecodedBinaryOpcode(Record[0], CurTy);
|
int Opc = GetDecodedBinaryOpcode(Record[0], CurTy);
|
||||||
if (Opc < 0) {
|
if (Opc < 0) {
|
||||||
V = Context.getUndef(CurTy); // Unknown binop.
|
V = UndefValue::get(CurTy); // Unknown binop.
|
||||||
} else {
|
} else {
|
||||||
Constant *LHS = ValueList.getConstantFwdRef(Record[1], CurTy);
|
Constant *LHS = ValueList.getConstantFwdRef(Record[1], CurTy);
|
||||||
Constant *RHS = ValueList.getConstantFwdRef(Record[2], CurTy);
|
Constant *RHS = ValueList.getConstantFwdRef(Record[2], CurTy);
|
||||||
@ -1015,7 +1015,7 @@ bool BitcodeReader::ParseConstants() {
|
|||||||
if (Record.size() < 3) return Error("Invalid CE_CAST record");
|
if (Record.size() < 3) return Error("Invalid CE_CAST record");
|
||||||
int Opc = GetDecodedCastOpcode(Record[0]);
|
int Opc = GetDecodedCastOpcode(Record[0]);
|
||||||
if (Opc < 0) {
|
if (Opc < 0) {
|
||||||
V = Context.getUndef(CurTy); // Unknown cast.
|
V = UndefValue::get(CurTy); // Unknown cast.
|
||||||
} else {
|
} else {
|
||||||
const Type *OpTy = getTypeByID(Record[1]);
|
const Type *OpTy = getTypeByID(Record[1]);
|
||||||
if (!OpTy) return Error("Invalid CE_CAST record");
|
if (!OpTy) return Error("Invalid CE_CAST record");
|
||||||
@ -1780,7 +1780,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
|
|||||||
if (Vs.size() > 1 ||
|
if (Vs.size() > 1 ||
|
||||||
(isa<StructType>(ReturnType) &&
|
(isa<StructType>(ReturnType) &&
|
||||||
(Vs.empty() || Vs[0]->getType() != 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) {
|
for (unsigned i = 0, e = Vs.size(); i != e; ++i) {
|
||||||
I = InsertValueInst::Create(RV, Vs[i], i, "mrv");
|
I = InsertValueInst::Create(RV, Vs[i], i, "mrv");
|
||||||
CurBB->getInstList().push_back(I);
|
CurBB->getInstList().push_back(I);
|
||||||
@ -2060,7 +2060,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
|
|||||||
// We found at least one unresolved value. Nuke them all to avoid leaks.
|
// We found at least one unresolved value. Nuke them all to avoid leaks.
|
||||||
for (unsigned i = ModuleValueListSize, e = ValueList.size(); i != e; ++i){
|
for (unsigned i = ModuleValueListSize, e = ValueList.size(); i != e; ++i){
|
||||||
if ((A = dyn_cast<Argument>(ValueList.back())) && A->getParent() == 0) {
|
if ((A = dyn_cast<Argument>(ValueList.back())) && A->getParent() == 0) {
|
||||||
A->replaceAllUsesWith(Context.getUndef(A->getType()));
|
A->replaceAllUsesWith(UndefValue::get(A->getType()));
|
||||||
delete A;
|
delete A;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -1789,7 +1789,6 @@ SDValue SelectionDAGLegalize::ExpandSCALAR_TO_VECTOR(SDNode *Node) {
|
|||||||
/// ExpandBUILD_VECTOR - Expand a BUILD_VECTOR node on targets that don't
|
/// ExpandBUILD_VECTOR - Expand a BUILD_VECTOR node on targets that don't
|
||||||
/// support the operation, but do support the resultant vector type.
|
/// support the operation, but do support the resultant vector type.
|
||||||
SDValue SelectionDAGLegalize::ExpandBUILD_VECTOR(SDNode *Node) {
|
SDValue SelectionDAGLegalize::ExpandBUILD_VECTOR(SDNode *Node) {
|
||||||
LLVMContext *Context = DAG.getContext();
|
|
||||||
unsigned NumElems = Node->getNumOperands();
|
unsigned NumElems = Node->getNumOperands();
|
||||||
SDValue Value1, Value2;
|
SDValue Value1, Value2;
|
||||||
DebugLoc dl = Node->getDebugLoc();
|
DebugLoc dl = Node->getDebugLoc();
|
||||||
@ -1840,7 +1839,7 @@ SDValue SelectionDAGLegalize::ExpandBUILD_VECTOR(SDNode *Node) {
|
|||||||
} else {
|
} else {
|
||||||
assert(Node->getOperand(i).getOpcode() == ISD::UNDEF);
|
assert(Node->getOperand(i).getOpcode() == ISD::UNDEF);
|
||||||
const Type *OpNTy = OpVT.getTypeForMVT();
|
const Type *OpNTy = OpVT.getTypeForMVT();
|
||||||
CV.push_back(Context->getUndef(OpNTy));
|
CV.push_back(UndefValue::get(OpNTy));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
Constant *CP = ConstantVector::get(CV);
|
Constant *CP = ConstantVector::get(CV);
|
||||||
|
@ -758,7 +758,7 @@ bool DAE::RemoveDeadStuffFromFunction(Function *F) {
|
|||||||
}
|
}
|
||||||
|
|
||||||
if (ExtraArgHack)
|
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.
|
// Push any varargs arguments on the list. Don't forget their attributes.
|
||||||
for (CallSite::arg_iterator E = CS.arg_end(); I != E; ++I, ++i) {
|
for (CallSite::arg_iterator E = CS.arg_end(); I != E; ++I, ++i) {
|
||||||
@ -814,7 +814,7 @@ bool DAE::RemoveDeadStuffFromFunction(Function *F) {
|
|||||||
// extract/insertvalue chaining and let instcombine clean that up.
|
// extract/insertvalue chaining and let instcombine clean that up.
|
||||||
//
|
//
|
||||||
// Start out building up our return value from undef
|
// 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)
|
for (unsigned i = 0; i != RetCount; ++i)
|
||||||
if (NewRetIdxs[i] != -1) {
|
if (NewRetIdxs[i] != -1) {
|
||||||
Value *V;
|
Value *V;
|
||||||
@ -881,7 +881,7 @@ bool DAE::RemoveDeadStuffFromFunction(Function *F) {
|
|||||||
// clean that up.
|
// clean that up.
|
||||||
Value *OldRet = RI->getOperand(0);
|
Value *OldRet = RI->getOperand(0);
|
||||||
// Start out building up our return value from undef
|
// Start out building up our return value from undef
|
||||||
RetVal = Context.getUndef(NRetTy);
|
RetVal = UndefValue::get(NRetTy);
|
||||||
for (unsigned i = 0; i != RetCount; ++i)
|
for (unsigned i = 0; i != RetCount; ++i)
|
||||||
if (NewRetIdxs[i] != -1) {
|
if (NewRetIdxs[i] != -1) {
|
||||||
ExtractValueInst *EV = ExtractValueInst::Create(OldRet, i,
|
ExtractValueInst *EV = ExtractValueInst::Create(OldRet, i,
|
||||||
|
@ -269,10 +269,10 @@ static Constant *getAggregateConstantElement(Constant *Agg, Constant *Idx,
|
|||||||
} else if (isa<UndefValue>(Agg)) {
|
} else if (isa<UndefValue>(Agg)) {
|
||||||
if (const StructType *STy = dyn_cast<StructType>(Agg->getType())) {
|
if (const StructType *STy = dyn_cast<StructType>(Agg->getType())) {
|
||||||
if (IdxV < STy->getNumElements())
|
if (IdxV < STy->getNumElements())
|
||||||
return Context.getUndef(STy->getElementType(IdxV));
|
return UndefValue::get(STy->getElementType(IdxV));
|
||||||
} else if (const SequentialType *STy =
|
} else if (const SequentialType *STy =
|
||||||
dyn_cast<SequentialType>(Agg->getType())) {
|
dyn_cast<SequentialType>(Agg->getType())) {
|
||||||
return Context.getUndef(STy->getElementType());
|
return UndefValue::get(STy->getElementType());
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
return 0;
|
return 0;
|
||||||
@ -844,7 +844,7 @@ static GlobalVariable *OptimizeGlobalAddressOfMalloc(GlobalVariable *GV,
|
|||||||
// FIXME: This new global should have the alignment returned by malloc. Code
|
// 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
|
// could depend on malloc returning large alignment (on the mac, 16 bytes) but
|
||||||
// this would only guarantee some lower alignment.
|
// 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(),
|
GlobalVariable *NewGV = new GlobalVariable(*GV->getParent(),
|
||||||
MI->getAllocatedType(), false,
|
MI->getAllocatedType(), false,
|
||||||
GlobalValue::InternalLinkage, Init,
|
GlobalValue::InternalLinkage, Init,
|
||||||
@ -2056,7 +2056,7 @@ static Constant *EvaluateStoreInto(Constant *Init, Constant *Val,
|
|||||||
Elts.push_back(Context.getNullValue(STy->getElementType(i)));
|
Elts.push_back(Context.getNullValue(STy->getElementType(i)));
|
||||||
} else if (isa<UndefValue>(Init)) {
|
} else if (isa<UndefValue>(Init)) {
|
||||||
for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i)
|
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 {
|
} else {
|
||||||
llvm_unreachable("This code is out of sync with "
|
llvm_unreachable("This code is out of sync with "
|
||||||
" ConstantFoldLoadThroughGEPConstantExpr");
|
" ConstantFoldLoadThroughGEPConstantExpr");
|
||||||
@ -2083,7 +2083,7 @@ static Constant *EvaluateStoreInto(Constant *Init, Constant *Val,
|
|||||||
Constant *Elt = Context.getNullValue(ATy->getElementType());
|
Constant *Elt = Context.getNullValue(ATy->getElementType());
|
||||||
Elts.assign(ATy->getNumElements(), Elt);
|
Elts.assign(ATy->getNumElements(), Elt);
|
||||||
} else if (isa<UndefValue>(Init)) {
|
} else if (isa<UndefValue>(Init)) {
|
||||||
Constant *Elt = Context.getUndef(ATy->getElementType());
|
Constant *Elt = UndefValue::get(ATy->getElementType());
|
||||||
Elts.assign(ATy->getNumElements(), Elt);
|
Elts.assign(ATy->getNumElements(), Elt);
|
||||||
} else {
|
} else {
|
||||||
llvm_unreachable("This code is out of sync with "
|
llvm_unreachable("This code is out of sync with "
|
||||||
@ -2227,7 +2227,7 @@ static bool EvaluateFunction(Function *F, Constant *&RetVal,
|
|||||||
const Type *Ty = AI->getType()->getElementType();
|
const Type *Ty = AI->getType()->getElementType();
|
||||||
AllocaTmps.push_back(new GlobalVariable(Context, Ty, false,
|
AllocaTmps.push_back(new GlobalVariable(Context, Ty, false,
|
||||||
GlobalValue::InternalLinkage,
|
GlobalValue::InternalLinkage,
|
||||||
Context.getUndef(Ty),
|
UndefValue::get(Ty),
|
||||||
AI->getName()));
|
AI->getName()));
|
||||||
InstResult = AllocaTmps.back();
|
InstResult = AllocaTmps.back();
|
||||||
} else if (CallInst *CI = dyn_cast<CallInst>(CurInst)) {
|
} else if (CallInst *CI = dyn_cast<CallInst>(CurInst)) {
|
||||||
|
@ -134,7 +134,7 @@ bool IPCP::PropagateConstantsIntoArguments(Function &F) {
|
|||||||
continue;
|
continue;
|
||||||
|
|
||||||
Value *V = ArgumentConstants[i].first;
|
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);
|
AI->replaceAllUsesWith(V);
|
||||||
++NumArgumentsProped;
|
++NumArgumentsProped;
|
||||||
MadeChange = true;
|
MadeChange = true;
|
||||||
@ -167,9 +167,9 @@ bool IPCP::PropagateConstantReturn(Function &F) {
|
|||||||
const StructType *STy = dyn_cast<StructType>(F.getReturnType());
|
const StructType *STy = dyn_cast<StructType>(F.getReturnType());
|
||||||
if (STy)
|
if (STy)
|
||||||
for (unsigned i = 0, e = STy->getNumElements(); i < e; ++i)
|
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
|
else
|
||||||
RetVals.push_back(Context.getUndef(F.getReturnType()));
|
RetVals.push_back(UndefValue::get(F.getReturnType()));
|
||||||
|
|
||||||
unsigned NumNonConstant = 0;
|
unsigned NumNonConstant = 0;
|
||||||
for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB)
|
for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB)
|
||||||
|
@ -289,8 +289,7 @@ void LowerSetJmp::TransformLongJmpCall(CallInst* Inst)
|
|||||||
Removed = &BB->back();
|
Removed = &BB->back();
|
||||||
// If the removed instructions have any users, replace them now.
|
// If the removed instructions have any users, replace them now.
|
||||||
if (!Removed->use_empty())
|
if (!Removed->use_empty())
|
||||||
Removed->replaceAllUsesWith(
|
Removed->replaceAllUsesWith(UndefValue::get(Removed->getType()));
|
||||||
Inst->getContext().getUndef(Removed->getType()));
|
|
||||||
Removed->eraseFromParent();
|
Removed->eraseFromParent();
|
||||||
} while (Removed != Inst);
|
} while (Removed != Inst);
|
||||||
|
|
||||||
|
@ -243,7 +243,7 @@ void PruneEH::DeleteBasicBlock(BasicBlock *BB) {
|
|||||||
} else if (InvokeInst *II = dyn_cast<InvokeInst>(I))
|
} else if (InvokeInst *II = dyn_cast<InvokeInst>(I))
|
||||||
CGN->removeCallEdgeFor(II);
|
CGN->removeCallEdgeFor(II);
|
||||||
if (!I->use_empty())
|
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.
|
// Get the list of successors of this block.
|
||||||
|
@ -142,8 +142,6 @@ bool RaiseAllocations::runOnModule(Module &M) {
|
|||||||
// Find the malloc/free prototypes...
|
// Find the malloc/free prototypes...
|
||||||
doInitialization(M);
|
doInitialization(M);
|
||||||
|
|
||||||
LLVMContext &Context = M.getContext();
|
|
||||||
|
|
||||||
bool Changed = false;
|
bool Changed = false;
|
||||||
|
|
||||||
// First, process all of the malloc calls...
|
// First, process all of the malloc calls...
|
||||||
@ -233,7 +231,7 @@ bool RaiseAllocations::runOnModule(Module &M) {
|
|||||||
|
|
||||||
// Delete the old call site
|
// Delete the old call site
|
||||||
if (I->getType() != Type::VoidTy)
|
if (I->getType() != Type::VoidTy)
|
||||||
I->replaceAllUsesWith(Context.getUndef(I->getType()));
|
I->replaceAllUsesWith(UndefValue::get(I->getType()));
|
||||||
I->eraseFromParent();
|
I->eraseFromParent();
|
||||||
Changed = true;
|
Changed = true;
|
||||||
++NumRaised;
|
++NumRaised;
|
||||||
|
@ -232,7 +232,7 @@ bool StripDebugInfo(Module &M) {
|
|||||||
if (!GV) continue;
|
if (!GV) continue;
|
||||||
if (!GV->use_empty() && llvmUsedValues.count(I) == 0) {
|
if (!GV->use_empty() && llvmUsedValues.count(I) == 0) {
|
||||||
if (GV->getName().startswith("llvm.dbg")) {
|
if (GV->getName().startswith("llvm.dbg")) {
|
||||||
GV->replaceAllUsesWith(M.getContext().getUndef(GV->getType()));
|
GV->replaceAllUsesWith(UndefValue::get(GV->getType()));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -53,7 +53,7 @@ void llvm::InsertProfilingInitCall(Function *MainFn, const char *FnName,
|
|||||||
} else {
|
} else {
|
||||||
// If this profiling instrumentation doesn't have a constant array, just
|
// If this profiling instrumentation doesn't have a constant array, just
|
||||||
// pass null.
|
// pass null.
|
||||||
Args[2] = Context.getConstantPointerNull(UIntPtr);
|
Args[2] = ConstantPointerNull::get(UIntPtr);
|
||||||
}
|
}
|
||||||
Args[3] = ConstantInt::get(Type::Int32Ty, NumElements);
|
Args[3] = ConstantInt::get(Type::Int32Ty, NumElements);
|
||||||
|
|
||||||
|
@ -798,7 +798,7 @@ Value *GVN::GetValueForBlock(BasicBlock *BB, Instruction* orig,
|
|||||||
// If the block is unreachable, just return undef, since this path
|
// If the block is unreachable, just return undef, since this path
|
||||||
// can't actually occur at runtime.
|
// can't actually occur at runtime.
|
||||||
if (!DT->isReachableFromEntry(BB))
|
if (!DT->isReachableFromEntry(BB))
|
||||||
return Phis[BB] = BB->getContext().getUndef(orig->getType());
|
return Phis[BB] = UndefValue::get(orig->getType());
|
||||||
|
|
||||||
if (BasicBlock *Pred = BB->getSinglePredecessor()) {
|
if (BasicBlock *Pred = BB->getSinglePredecessor()) {
|
||||||
Value *ret = GetValueForBlock(Pred, orig, Phis);
|
Value *ret = GetValueForBlock(Pred, orig, Phis);
|
||||||
@ -985,8 +985,8 @@ bool GVN::processNonLocalLoad(LoadInst *LI,
|
|||||||
|
|
||||||
// Loading the allocation -> undef.
|
// Loading the allocation -> undef.
|
||||||
if (isa<AllocationInst>(DepInst)) {
|
if (isa<AllocationInst>(DepInst)) {
|
||||||
ValuesPerBlock.push_back(std::make_pair(DepBB,
|
ValuesPerBlock.push_back(std::make_pair(DepBB,
|
||||||
DepBB->getContext().getUndef(LI->getType())));
|
UndefValue::get(LI->getType())));
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -1273,7 +1273,7 @@ bool GVN::processLoad(LoadInst *L, SmallVectorImpl<Instruction*> &toErase) {
|
|||||||
// undef value. This can happen when loading for a fresh allocation with no
|
// undef value. This can happen when loading for a fresh allocation with no
|
||||||
// intervening stores, for example.
|
// intervening stores, for example.
|
||||||
if (isa<AllocationInst>(DepInst)) {
|
if (isa<AllocationInst>(DepInst)) {
|
||||||
L->replaceAllUsesWith(DepInst->getContext().getUndef(L->getType()));
|
L->replaceAllUsesWith(UndefValue::get(L->getType()));
|
||||||
toErase.push_back(L);
|
toErase.push_back(L);
|
||||||
NumGVNLoad++;
|
NumGVNLoad++;
|
||||||
return true;
|
return true;
|
||||||
|
@ -713,8 +713,6 @@ void IndVarSimplify::HandleFloatingPointIV(Loop *L, PHINode *PH) {
|
|||||||
}
|
}
|
||||||
if (NewPred == CmpInst::BAD_ICMP_PREDICATE) return;
|
if (NewPred == CmpInst::BAD_ICMP_PREDICATE) return;
|
||||||
|
|
||||||
LLVMContext &Context = PH->getContext();
|
|
||||||
|
|
||||||
// Insert new integer induction variable.
|
// Insert new integer induction variable.
|
||||||
PHINode *NewPHI = PHINode::Create(Type::Int32Ty,
|
PHINode *NewPHI = PHINode::Create(Type::Int32Ty,
|
||||||
PH->getName()+".int", PH);
|
PH->getName()+".int", PH);
|
||||||
@ -745,7 +743,7 @@ void IndVarSimplify::HandleFloatingPointIV(Loop *L, PHINode *PH) {
|
|||||||
RecursivelyDeleteTriviallyDeadInstructions(EC);
|
RecursivelyDeleteTriviallyDeadInstructions(EC);
|
||||||
|
|
||||||
// Delete old, floating point, increment instruction.
|
// Delete old, floating point, increment instruction.
|
||||||
Incr->replaceAllUsesWith(Context.getUndef(Incr->getType()));
|
Incr->replaceAllUsesWith(UndefValue::get(Incr->getType()));
|
||||||
RecursivelyDeleteTriviallyDeadInstructions(Incr);
|
RecursivelyDeleteTriviallyDeadInstructions(Incr);
|
||||||
|
|
||||||
// Replace floating induction variable, if it isn't already deleted.
|
// Replace floating induction variable, if it isn't already deleted.
|
||||||
|
@ -147,7 +147,7 @@ namespace {
|
|||||||
if (Instruction *Op = dyn_cast<Instruction>(*i)) {
|
if (Instruction *Op = dyn_cast<Instruction>(*i)) {
|
||||||
AddToWorkList(Op);
|
AddToWorkList(Op);
|
||||||
// Set the operand to undef to drop the use.
|
// Set the operand to undef to drop the use.
|
||||||
*i = Context->getUndef(Op->getType());
|
*i = UndefValue::get(Op->getType());
|
||||||
}
|
}
|
||||||
|
|
||||||
return R;
|
return R;
|
||||||
@ -312,7 +312,7 @@ namespace {
|
|||||||
} else {
|
} else {
|
||||||
// If we are replacing the instruction with itself, this must be in a
|
// If we are replacing the instruction with itself, this must be in a
|
||||||
// segment of unreachable code, so just clobber the instruction.
|
// segment of unreachable code, so just clobber the instruction.
|
||||||
I.replaceAllUsesWith(Context->getUndef(I.getType()));
|
I.replaceAllUsesWith(UndefValue::get(I.getType()));
|
||||||
return &I;
|
return &I;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -815,7 +815,7 @@ Value *InstCombiner::SimplifyDemandedUseBits(Value *V, APInt DemandedMask,
|
|||||||
if (DemandedMask == 0) { // Not demanding any bits from V.
|
if (DemandedMask == 0) { // Not demanding any bits from V.
|
||||||
if (isa<UndefValue>(V))
|
if (isa<UndefValue>(V))
|
||||||
return 0;
|
return 0;
|
||||||
return Context->getUndef(VTy);
|
return UndefValue::get(VTy);
|
||||||
}
|
}
|
||||||
|
|
||||||
if (Depth == 6) // Limit search depth.
|
if (Depth == 6) // Limit search depth.
|
||||||
@ -1437,13 +1437,13 @@ Value *InstCombiner::SimplifyDemandedVectorElts(Value *V, APInt DemandedElts,
|
|||||||
return 0;
|
return 0;
|
||||||
} else if (DemandedElts == 0) { // If nothing is demanded, provide undef.
|
} else if (DemandedElts == 0) { // If nothing is demanded, provide undef.
|
||||||
UndefElts = EltMask;
|
UndefElts = EltMask;
|
||||||
return Context->getUndef(V->getType());
|
return UndefValue::get(V->getType());
|
||||||
}
|
}
|
||||||
|
|
||||||
UndefElts = 0;
|
UndefElts = 0;
|
||||||
if (ConstantVector *CP = dyn_cast<ConstantVector>(V)) {
|
if (ConstantVector *CP = dyn_cast<ConstantVector>(V)) {
|
||||||
const Type *EltTy = cast<VectorType>(V->getType())->getElementType();
|
const Type *EltTy = cast<VectorType>(V->getType())->getElementType();
|
||||||
Constant *Undef = Context->getUndef(EltTy);
|
Constant *Undef = UndefValue::get(EltTy);
|
||||||
|
|
||||||
std::vector<Constant*> Elts;
|
std::vector<Constant*> Elts;
|
||||||
for (unsigned i = 0; i != VWidth; ++i)
|
for (unsigned i = 0; i != VWidth; ++i)
|
||||||
@ -1471,7 +1471,7 @@ Value *InstCombiner::SimplifyDemandedVectorElts(Value *V, APInt DemandedElts,
|
|||||||
|
|
||||||
const Type *EltTy = cast<VectorType>(V->getType())->getElementType();
|
const Type *EltTy = cast<VectorType>(V->getType())->getElementType();
|
||||||
Constant *Zero = Context->getNullValue(EltTy);
|
Constant *Zero = Context->getNullValue(EltTy);
|
||||||
Constant *Undef = Context->getUndef(EltTy);
|
Constant *Undef = UndefValue::get(EltTy);
|
||||||
std::vector<Constant*> Elts;
|
std::vector<Constant*> Elts;
|
||||||
for (unsigned i = 0; i != VWidth; ++i) {
|
for (unsigned i = 0; i != VWidth; ++i) {
|
||||||
Constant *Elt = DemandedElts[i] ? Zero : Undef;
|
Constant *Elt = DemandedElts[i] ? Zero : Undef;
|
||||||
@ -1592,7 +1592,7 @@ Value *InstCombiner::SimplifyDemandedVectorElts(Value *V, APInt DemandedElts,
|
|||||||
std::vector<Constant*> Elts;
|
std::vector<Constant*> Elts;
|
||||||
for (unsigned i = 0; i < VWidth; ++i) {
|
for (unsigned i = 0; i < VWidth; ++i) {
|
||||||
if (UndefElts[i])
|
if (UndefElts[i])
|
||||||
Elts.push_back(Context->getUndef(Type::Int32Ty));
|
Elts.push_back(UndefValue::get(Type::Int32Ty));
|
||||||
else
|
else
|
||||||
Elts.push_back(ConstantInt::get(Type::Int32Ty,
|
Elts.push_back(ConstantInt::get(Type::Int32Ty,
|
||||||
Shuffle->getMaskValue(i)));
|
Shuffle->getMaskValue(i)));
|
||||||
@ -1745,7 +1745,7 @@ Value *InstCombiner::SimplifyDemandedVectorElts(Value *V, APInt DemandedElts,
|
|||||||
|
|
||||||
Instruction *New =
|
Instruction *New =
|
||||||
InsertElementInst::Create(
|
InsertElementInst::Create(
|
||||||
Context->getUndef(II->getType()), TmpV,
|
UndefValue::get(II->getType()), TmpV,
|
||||||
ConstantInt::get(Type::Int32Ty, 0U, false), II->getName());
|
ConstantInt::get(Type::Int32Ty, 0U, false), II->getName());
|
||||||
InsertNewInstBefore(New, *II);
|
InsertNewInstBefore(New, *II);
|
||||||
AddSoonDeadInstToWorklist(*II, 0);
|
AddSoonDeadInstToWorklist(*II, 0);
|
||||||
@ -3138,7 +3138,7 @@ Instruction *InstCombiner::commonIRemTransforms(BinaryOperator &I) {
|
|||||||
if (ConstantInt *RHS = dyn_cast<ConstantInt>(Op1)) {
|
if (ConstantInt *RHS = dyn_cast<ConstantInt>(Op1)) {
|
||||||
// X % 0 == undef, we don't need to preserve faults!
|
// X % 0 == undef, we don't need to preserve faults!
|
||||||
if (RHS->equalsInt(0))
|
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
|
if (RHS->equalsInt(1)) // X % 1 == 0
|
||||||
return ReplaceInstUsesWith(I, Context->getNullValue(I.getType()));
|
return ReplaceInstUsesWith(I, Context->getNullValue(I.getType()));
|
||||||
@ -5907,7 +5907,7 @@ Instruction *InstCombiner::visitFCmpInst(FCmpInst &I) {
|
|||||||
}
|
}
|
||||||
|
|
||||||
if (isa<UndefValue>(Op1)) // fcmp pred X, undef -> undef
|
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
|
// Handle fcmp with constant RHS
|
||||||
if (Constant *RHSC = dyn_cast<Constant>(Op1)) {
|
if (Constant *RHSC = dyn_cast<Constant>(Op1)) {
|
||||||
@ -5981,7 +5981,7 @@ Instruction *InstCombiner::visitICmpInst(ICmpInst &I) {
|
|||||||
I.isTrueWhenEqual()));
|
I.isTrueWhenEqual()));
|
||||||
|
|
||||||
if (isa<UndefValue>(Op1)) // X icmp undef -> undef
|
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
|
// icmp <global/alloca*/null>, <global/alloca*/null> - Global/Stack value
|
||||||
// addresses never equal each other! We already know that Op0 != Op1.
|
// addresses never equal each other! We already know that Op0 != Op1.
|
||||||
@ -8995,7 +8995,7 @@ Instruction *InstCombiner::visitBitCast(BitCastInst &CI) {
|
|||||||
if (!isa<VectorType>(SrcTy)) {
|
if (!isa<VectorType>(SrcTy)) {
|
||||||
Value *Elem = InsertCastBefore(Instruction::BitCast, Src,
|
Value *Elem = InsertCastBefore(Instruction::BitCast, Src,
|
||||||
DestVTy->getElementType(), CI);
|
DestVTy->getElementType(), CI);
|
||||||
return InsertElementInst::Create(Context->getUndef(DestTy), Elem,
|
return InsertElementInst::Create(UndefValue::get(DestTy), Elem,
|
||||||
Context->getNullValue(Type::Int32Ty));
|
Context->getNullValue(Type::Int32Ty));
|
||||||
}
|
}
|
||||||
// FIXME: Canonicalize bitcast(insertelement) -> insertelement(bitcast)
|
// FIXME: Canonicalize bitcast(insertelement) -> insertelement(bitcast)
|
||||||
@ -9936,7 +9936,7 @@ Instruction *InstCombiner::visitCallInst(CallInst &CI) {
|
|||||||
// Cast the input vectors to byte vectors.
|
// Cast the input vectors to byte vectors.
|
||||||
Value *Op0 =InsertBitCastBefore(II->getOperand(1),Mask->getType(),CI);
|
Value *Op0 =InsertBitCastBefore(II->getOperand(1),Mask->getType(),CI);
|
||||||
Value *Op1 =InsertBitCastBefore(II->getOperand(2),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.
|
// Only extract each element once.
|
||||||
Value *ExtractedElts[32];
|
Value *ExtractedElts[32];
|
||||||
@ -10062,10 +10062,10 @@ Instruction *InstCombiner::visitCallSite(CallSite CS) {
|
|||||||
// If the call and callee calling conventions don't match, this call must
|
// If the call and callee calling conventions don't match, this call must
|
||||||
// be unreachable, as the call is undefined.
|
// be unreachable, as the call is undefined.
|
||||||
new StoreInst(Context->getTrue(),
|
new StoreInst(Context->getTrue(),
|
||||||
Context->getUndef(PointerType::getUnqual(Type::Int1Ty)),
|
UndefValue::get(PointerType::getUnqual(Type::Int1Ty)),
|
||||||
OldCall);
|
OldCall);
|
||||||
if (!OldCall->use_empty())
|
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.
|
if (isa<CallInst>(OldCall)) // Not worth removing an invoke here.
|
||||||
return EraseInstFromFunction(*OldCall);
|
return EraseInstFromFunction(*OldCall);
|
||||||
return 0;
|
return 0;
|
||||||
@ -10076,12 +10076,12 @@ Instruction *InstCombiner::visitCallSite(CallSite CS) {
|
|||||||
// undef so that we know that this code is not reachable, despite the fact
|
// undef so that we know that this code is not reachable, despite the fact
|
||||||
// that we can't modify the CFG here.
|
// that we can't modify the CFG here.
|
||||||
new StoreInst(Context->getTrue(),
|
new StoreInst(Context->getTrue(),
|
||||||
Context->getUndef(PointerType::getUnqual(Type::Int1Ty)),
|
UndefValue::get(PointerType::getUnqual(Type::Int1Ty)),
|
||||||
CS.getInstruction());
|
CS.getInstruction());
|
||||||
|
|
||||||
if (!CS.getInstruction()->use_empty())
|
if (!CS.getInstruction()->use_empty())
|
||||||
CS.getInstruction()->
|
CS.getInstruction()->
|
||||||
replaceAllUsesWith(Context->getUndef(CS.getInstruction()->getType()));
|
replaceAllUsesWith(UndefValue::get(CS.getInstruction()->getType()));
|
||||||
|
|
||||||
if (InvokeInst *II = dyn_cast<InvokeInst>(CS.getInstruction())) {
|
if (InvokeInst *II = dyn_cast<InvokeInst>(CS.getInstruction())) {
|
||||||
// Don't break the CFG, insert a dummy cond branch.
|
// Don't break the CFG, insert a dummy cond branch.
|
||||||
@ -10333,7 +10333,7 @@ bool InstCombiner::transformConstExprCastCall(CallSite CS) {
|
|||||||
}
|
}
|
||||||
AddUsersToWorkList(*Caller);
|
AddUsersToWorkList(*Caller);
|
||||||
} else {
|
} else {
|
||||||
NV = Context->getUndef(Caller->getType());
|
NV = UndefValue::get(Caller->getType());
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -10921,7 +10921,7 @@ Instruction *InstCombiner::visitPHINode(PHINode &PN) {
|
|||||||
SmallPtrSet<PHINode*, 16> PotentiallyDeadPHIs;
|
SmallPtrSet<PHINode*, 16> PotentiallyDeadPHIs;
|
||||||
PotentiallyDeadPHIs.insert(&PN);
|
PotentiallyDeadPHIs.insert(&PN);
|
||||||
if (DeadPHICycle(PU, PotentiallyDeadPHIs))
|
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 this phi has a single use, and if that use just computes a value for
|
||||||
@ -10933,7 +10933,7 @@ Instruction *InstCombiner::visitPHINode(PHINode &PN) {
|
|||||||
if (PHIUser->hasOneUse() &&
|
if (PHIUser->hasOneUse() &&
|
||||||
(isa<BinaryOperator>(PHIUser) || isa<GetElementPtrInst>(PHIUser)) &&
|
(isa<BinaryOperator>(PHIUser) || isa<GetElementPtrInst>(PHIUser)) &&
|
||||||
PHIUser->use_back() == &PN) {
|
PHIUser->use_back() == &PN) {
|
||||||
return ReplaceInstUsesWith(PN, Context->getUndef(PN.getType()));
|
return ReplaceInstUsesWith(PN, UndefValue::get(PN.getType()));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -10997,7 +10997,7 @@ Instruction *InstCombiner::visitGetElementPtrInst(GetElementPtrInst &GEP) {
|
|||||||
return ReplaceInstUsesWith(GEP, PtrOp);
|
return ReplaceInstUsesWith(GEP, PtrOp);
|
||||||
|
|
||||||
if (isa<UndefValue>(GEP.getOperand(0)))
|
if (isa<UndefValue>(GEP.getOperand(0)))
|
||||||
return ReplaceInstUsesWith(GEP, Context->getUndef(GEP.getType()));
|
return ReplaceInstUsesWith(GEP, UndefValue::get(GEP.getType()));
|
||||||
|
|
||||||
bool HasZeroPointerIndex = false;
|
bool HasZeroPointerIndex = false;
|
||||||
if (Constant *C = dyn_cast<Constant>(GEP.getOperand(1)))
|
if (Constant *C = dyn_cast<Constant>(GEP.getOperand(1)))
|
||||||
@ -11426,7 +11426,7 @@ Instruction *InstCombiner::visitFreeInst(FreeInst &FI) {
|
|||||||
if (isa<UndefValue>(Op)) {
|
if (isa<UndefValue>(Op)) {
|
||||||
// Insert a new store to null because we cannot modify the CFG here.
|
// Insert a new store to null because we cannot modify the CFG here.
|
||||||
new StoreInst(Context->getTrue(),
|
new StoreInst(Context->getTrue(),
|
||||||
Context->getUndef(PointerType::getUnqual(Type::Int1Ty)), &FI);
|
UndefValue::get(PointerType::getUnqual(Type::Int1Ty)), &FI);
|
||||||
return EraseInstFromFunction(FI);
|
return EraseInstFromFunction(FI);
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -11587,9 +11587,9 @@ Instruction *InstCombiner::visitLoadInst(LoadInst &LI) {
|
|||||||
// that this code is not reachable. We do this instead of inserting
|
// that this code is not reachable. We do this instead of inserting
|
||||||
// an unreachable instruction directly because we cannot modify the
|
// an unreachable instruction directly because we cannot modify the
|
||||||
// CFG.
|
// CFG.
|
||||||
new StoreInst(Context->getUndef(LI.getType()),
|
new StoreInst(UndefValue::get(LI.getType()),
|
||||||
Context->getNullValue(Op->getType()), &LI);
|
Context->getNullValue(Op->getType()), &LI);
|
||||||
return ReplaceInstUsesWith(LI, Context->getUndef(LI.getType()));
|
return ReplaceInstUsesWith(LI, UndefValue::get(LI.getType()));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -11601,9 +11601,9 @@ Instruction *InstCombiner::visitLoadInst(LoadInst &LI) {
|
|||||||
// Insert a new store to null instruction before the load to indicate that
|
// 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
|
// this code is not reachable. We do this instead of inserting an
|
||||||
// unreachable instruction directly because we cannot modify the CFG.
|
// 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);
|
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.
|
// Instcombine load (constant global) into the value loaded.
|
||||||
@ -11625,9 +11625,9 @@ Instruction *InstCombiner::visitLoadInst(LoadInst &LI) {
|
|||||||
// that this code is not reachable. We do this instead of inserting
|
// that this code is not reachable. We do this instead of inserting
|
||||||
// an unreachable instruction directly because we cannot modify the
|
// an unreachable instruction directly because we cannot modify the
|
||||||
// CFG.
|
// CFG.
|
||||||
new StoreInst(Context->getUndef(LI.getType()),
|
new StoreInst(UndefValue::get(LI.getType()),
|
||||||
Context->getNullValue(Op->getType()), &LI);
|
Context->getNullValue(Op->getType()), &LI);
|
||||||
return ReplaceInstUsesWith(LI, Context->getUndef(LI.getType()));
|
return ReplaceInstUsesWith(LI, UndefValue::get(LI.getType()));
|
||||||
}
|
}
|
||||||
|
|
||||||
} else if (CE->isCast()) {
|
} else if (CE->isCast()) {
|
||||||
@ -11644,7 +11644,7 @@ Instruction *InstCombiner::visitLoadInst(LoadInst &LI) {
|
|||||||
if (GV->getInitializer()->isNullValue())
|
if (GV->getInitializer()->isNullValue())
|
||||||
return ReplaceInstUsesWith(LI, Context->getNullValue(LI.getType()));
|
return ReplaceInstUsesWith(LI, Context->getNullValue(LI.getType()));
|
||||||
else if (isa<UndefValue>(GV->getInitializer()))
|
else if (isa<UndefValue>(GV->getInitializer()))
|
||||||
return ReplaceInstUsesWith(LI, Context->getUndef(LI.getType()));
|
return ReplaceInstUsesWith(LI, UndefValue::get(LI.getType()));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -11941,7 +11941,7 @@ Instruction *InstCombiner::visitStoreInst(StoreInst &SI) {
|
|||||||
if (isa<ConstantPointerNull>(Ptr) &&
|
if (isa<ConstantPointerNull>(Ptr) &&
|
||||||
cast<PointerType>(Ptr->getType())->getAddressSpace() == 0) {
|
cast<PointerType>(Ptr->getType())->getAddressSpace() == 0) {
|
||||||
if (!isa<UndefValue>(Val)) {
|
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))
|
if (Instruction *U = dyn_cast<Instruction>(Val))
|
||||||
AddToWorkList(U); // Dropped a use.
|
AddToWorkList(U); // Dropped a use.
|
||||||
++NumCombined;
|
++NumCombined;
|
||||||
@ -12187,7 +12187,7 @@ Instruction *InstCombiner::visitExtractValueInst(ExtractValueInst &EV) {
|
|||||||
|
|
||||||
if (Constant *C = dyn_cast<Constant>(Agg)) {
|
if (Constant *C = dyn_cast<Constant>(Agg)) {
|
||||||
if (isa<UndefValue>(C))
|
if (isa<UndefValue>(C))
|
||||||
return ReplaceInstUsesWith(EV, Context->getUndef(EV.getType()));
|
return ReplaceInstUsesWith(EV, UndefValue::get(EV.getType()));
|
||||||
|
|
||||||
if (isa<ConstantAggregateZero>(C))
|
if (isa<ConstantAggregateZero>(C))
|
||||||
return ReplaceInstUsesWith(EV, Context->getNullValue(EV.getType()));
|
return ReplaceInstUsesWith(EV, Context->getNullValue(EV.getType()));
|
||||||
@ -12332,10 +12332,10 @@ static Value *FindScalarElement(Value *V, unsigned EltNo,
|
|||||||
const VectorType *PTy = cast<VectorType>(V->getType());
|
const VectorType *PTy = cast<VectorType>(V->getType());
|
||||||
unsigned Width = PTy->getNumElements();
|
unsigned Width = PTy->getNumElements();
|
||||||
if (EltNo >= Width) // Out of range access.
|
if (EltNo >= Width) // Out of range access.
|
||||||
return Context->getUndef(PTy->getElementType());
|
return UndefValue::get(PTy->getElementType());
|
||||||
|
|
||||||
if (isa<UndefValue>(V))
|
if (isa<UndefValue>(V))
|
||||||
return Context->getUndef(PTy->getElementType());
|
return UndefValue::get(PTy->getElementType());
|
||||||
else if (isa<ConstantAggregateZero>(V))
|
else if (isa<ConstantAggregateZero>(V))
|
||||||
return Context->getNullValue(PTy->getElementType());
|
return Context->getNullValue(PTy->getElementType());
|
||||||
else if (ConstantVector *CP = dyn_cast<ConstantVector>(V))
|
else if (ConstantVector *CP = dyn_cast<ConstantVector>(V))
|
||||||
@ -12363,7 +12363,7 @@ static Value *FindScalarElement(Value *V, unsigned EltNo,
|
|||||||
else if (InEl < LHSWidth*2)
|
else if (InEl < LHSWidth*2)
|
||||||
return FindScalarElement(SVI->getOperand(1), InEl - LHSWidth, Context);
|
return FindScalarElement(SVI->getOperand(1), InEl - LHSWidth, Context);
|
||||||
else
|
else
|
||||||
return Context->getUndef(PTy->getElementType());
|
return UndefValue::get(PTy->getElementType());
|
||||||
}
|
}
|
||||||
|
|
||||||
// Otherwise, we don't know.
|
// Otherwise, we don't know.
|
||||||
@ -12373,7 +12373,7 @@ static Value *FindScalarElement(Value *V, unsigned EltNo,
|
|||||||
Instruction *InstCombiner::visitExtractElementInst(ExtractElementInst &EI) {
|
Instruction *InstCombiner::visitExtractElementInst(ExtractElementInst &EI) {
|
||||||
// If vector val is undef, replace extract with scalar undef.
|
// If vector val is undef, replace extract with scalar undef.
|
||||||
if (isa<UndefValue>(EI.getOperand(0)))
|
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 vector val is constant 0, replace extract with scalar 0.
|
||||||
if (isa<ConstantAggregateZero>(EI.getOperand(0)))
|
if (isa<ConstantAggregateZero>(EI.getOperand(0)))
|
||||||
@ -12403,7 +12403,7 @@ Instruction *InstCombiner::visitExtractElementInst(ExtractElementInst &EI) {
|
|||||||
// If this is extracting an invalid index, turn this into undef, to avoid
|
// If this is extracting an invalid index, turn this into undef, to avoid
|
||||||
// crashing the code below.
|
// crashing the code below.
|
||||||
if (IndexVal >= VectorWidth)
|
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.
|
// 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
|
// If the input vector has a single use, simplify it based on this use
|
||||||
@ -12490,7 +12490,7 @@ Instruction *InstCombiner::visitExtractElementInst(ExtractElementInst &EI) {
|
|||||||
SrcIdx -= LHSWidth;
|
SrcIdx -= LHSWidth;
|
||||||
Src = SVI->getOperand(1);
|
Src = SVI->getOperand(1);
|
||||||
} else {
|
} else {
|
||||||
return ReplaceInstUsesWith(EI, Context->getUndef(EI.getType()));
|
return ReplaceInstUsesWith(EI, UndefValue::get(EI.getType()));
|
||||||
}
|
}
|
||||||
return ExtractElementInst::Create(Src,
|
return ExtractElementInst::Create(Src,
|
||||||
ConstantInt::get(Type::Int32Ty, SrcIdx, false));
|
ConstantInt::get(Type::Int32Ty, SrcIdx, false));
|
||||||
@ -12512,7 +12512,7 @@ static bool CollectSingleShuffleElements(Value *V, Value *LHS, Value *RHS,
|
|||||||
unsigned NumElts = cast<VectorType>(V->getType())->getNumElements();
|
unsigned NumElts = cast<VectorType>(V->getType())->getNumElements();
|
||||||
|
|
||||||
if (isa<UndefValue>(V)) {
|
if (isa<UndefValue>(V)) {
|
||||||
Mask.assign(NumElts, Context->getUndef(Type::Int32Ty));
|
Mask.assign(NumElts, UndefValue::get(Type::Int32Ty));
|
||||||
return true;
|
return true;
|
||||||
} else if (V == LHS) {
|
} else if (V == LHS) {
|
||||||
for (unsigned i = 0; i != NumElts; ++i)
|
for (unsigned i = 0; i != NumElts; ++i)
|
||||||
@ -12537,7 +12537,7 @@ static bool CollectSingleShuffleElements(Value *V, Value *LHS, Value *RHS,
|
|||||||
// transitively ok.
|
// transitively ok.
|
||||||
if (CollectSingleShuffleElements(VecOp, LHS, RHS, Mask, Context)) {
|
if (CollectSingleShuffleElements(VecOp, LHS, RHS, Mask, Context)) {
|
||||||
// If so, update the mask to reflect the inserted undef.
|
// If so, update the mask to reflect the inserted undef.
|
||||||
Mask[InsertedIdx] = Context->getUndef(Type::Int32Ty);
|
Mask[InsertedIdx] = UndefValue::get(Type::Int32Ty);
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
} else if (ExtractElementInst *EI = dyn_cast<ExtractElementInst>(ScalarOp)){
|
} else if (ExtractElementInst *EI = dyn_cast<ExtractElementInst>(ScalarOp)){
|
||||||
@ -12583,7 +12583,7 @@ static Value *CollectShuffleElements(Value *V, std::vector<Constant*> &Mask,
|
|||||||
unsigned NumElts = cast<VectorType>(V->getType())->getNumElements();
|
unsigned NumElts = cast<VectorType>(V->getType())->getNumElements();
|
||||||
|
|
||||||
if (isa<UndefValue>(V)) {
|
if (isa<UndefValue>(V)) {
|
||||||
Mask.assign(NumElts, Context->getUndef(Type::Int32Ty));
|
Mask.assign(NumElts, UndefValue::get(Type::Int32Ty));
|
||||||
return V;
|
return V;
|
||||||
} else if (isa<ConstantAggregateZero>(V)) {
|
} else if (isa<ConstantAggregateZero>(V)) {
|
||||||
Mask.assign(NumElts, ConstantInt::get(Type::Int32Ty, 0));
|
Mask.assign(NumElts, ConstantInt::get(Type::Int32Ty, 0));
|
||||||
@ -12662,7 +12662,7 @@ Instruction *InstCombiner::visitInsertElementInst(InsertElementInst &IE) {
|
|||||||
return ReplaceInstUsesWith(IE, VecOp);
|
return ReplaceInstUsesWith(IE, VecOp);
|
||||||
|
|
||||||
if (InsertedIdx >= NumVectorElts) // Out of range insert.
|
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
|
// If we are extracting a value from a vector, then inserting it right
|
||||||
// back into the same place, just use the input vector.
|
// back into the same place, just use the input vector.
|
||||||
@ -12679,7 +12679,7 @@ Instruction *InstCombiner::visitInsertElementInst(InsertElementInst &IE) {
|
|||||||
// Build a new shuffle mask.
|
// Build a new shuffle mask.
|
||||||
std::vector<Constant*> Mask;
|
std::vector<Constant*> Mask;
|
||||||
if (isa<UndefValue>(VecOp))
|
if (isa<UndefValue>(VecOp))
|
||||||
Mask.assign(NumVectorElts, Context->getUndef(Type::Int32Ty));
|
Mask.assign(NumVectorElts, UndefValue::get(Type::Int32Ty));
|
||||||
else {
|
else {
|
||||||
assert(isa<ConstantAggregateZero>(VecOp) && "Unknown thing");
|
assert(isa<ConstantAggregateZero>(VecOp) && "Unknown thing");
|
||||||
Mask.assign(NumVectorElts, ConstantInt::get(Type::Int32Ty,
|
Mask.assign(NumVectorElts, ConstantInt::get(Type::Int32Ty,
|
||||||
@ -12697,7 +12697,7 @@ Instruction *InstCombiner::visitInsertElementInst(InsertElementInst &IE) {
|
|||||||
std::vector<Constant*> Mask;
|
std::vector<Constant*> Mask;
|
||||||
Value *RHS = 0;
|
Value *RHS = 0;
|
||||||
Value *LHS = CollectShuffleElements(&IE, Mask, RHS, Context);
|
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.
|
// We now have a shuffle of LHS, RHS, Mask.
|
||||||
return new ShuffleVectorInst(LHS, RHS,
|
return new ShuffleVectorInst(LHS, RHS,
|
||||||
ConstantVector::get(Mask));
|
ConstantVector::get(Mask));
|
||||||
@ -12724,7 +12724,7 @@ Instruction *InstCombiner::visitShuffleVectorInst(ShuffleVectorInst &SVI) {
|
|||||||
|
|
||||||
// Undefined shuffle mask -> undefined value.
|
// Undefined shuffle mask -> undefined value.
|
||||||
if (isa<UndefValue>(SVI.getOperand(2)))
|
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();
|
unsigned VWidth = cast<VectorType>(SVI.getType())->getNumElements();
|
||||||
|
|
||||||
@ -12751,12 +12751,12 @@ Instruction *InstCombiner::visitShuffleVectorInst(ShuffleVectorInst &SVI) {
|
|||||||
std::vector<Constant*> Elts;
|
std::vector<Constant*> Elts;
|
||||||
for (unsigned i = 0, e = Mask.size(); i != e; ++i) {
|
for (unsigned i = 0, e = Mask.size(); i != e; ++i) {
|
||||||
if (Mask[i] >= 2*e)
|
if (Mask[i] >= 2*e)
|
||||||
Elts.push_back(Context->getUndef(Type::Int32Ty));
|
Elts.push_back(UndefValue::get(Type::Int32Ty));
|
||||||
else {
|
else {
|
||||||
if ((Mask[i] >= e && isa<UndefValue>(RHS)) ||
|
if ((Mask[i] >= e && isa<UndefValue>(RHS)) ||
|
||||||
(Mask[i] < e && isa<UndefValue>(LHS))) {
|
(Mask[i] < e && isa<UndefValue>(LHS))) {
|
||||||
Mask[i] = 2*e; // Turn into undef.
|
Mask[i] = 2*e; // Turn into undef.
|
||||||
Elts.push_back(Context->getUndef(Type::Int32Ty));
|
Elts.push_back(UndefValue::get(Type::Int32Ty));
|
||||||
} else {
|
} else {
|
||||||
Mask[i] = Mask[i] % e; // Force to LHS.
|
Mask[i] = Mask[i] % e; // Force to LHS.
|
||||||
Elts.push_back(ConstantInt::get(Type::Int32Ty, Mask[i]));
|
Elts.push_back(ConstantInt::get(Type::Int32Ty, Mask[i]));
|
||||||
@ -12764,7 +12764,7 @@ Instruction *InstCombiner::visitShuffleVectorInst(ShuffleVectorInst &SVI) {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
SVI.setOperand(0, SVI.getOperand(1));
|
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));
|
SVI.setOperand(2, ConstantVector::get(Elts));
|
||||||
LHS = SVI.getOperand(0);
|
LHS = SVI.getOperand(0);
|
||||||
RHS = SVI.getOperand(1);
|
RHS = SVI.getOperand(1);
|
||||||
@ -12815,7 +12815,7 @@ Instruction *InstCombiner::visitShuffleVectorInst(ShuffleVectorInst &SVI) {
|
|||||||
std::vector<Constant*> Elts;
|
std::vector<Constant*> Elts;
|
||||||
for (unsigned i = 0, e = NewMask.size(); i != e; ++i) {
|
for (unsigned i = 0, e = NewMask.size(); i != e; ++i) {
|
||||||
if (NewMask[i] >= LHSInNElts*2) {
|
if (NewMask[i] >= LHSInNElts*2) {
|
||||||
Elts.push_back(Context->getUndef(Type::Int32Ty));
|
Elts.push_back(UndefValue::get(Type::Int32Ty));
|
||||||
} else {
|
} else {
|
||||||
Elts.push_back(ConstantInt::get(Type::Int32Ty, NewMask[i]));
|
Elts.push_back(ConstantInt::get(Type::Int32Ty, NewMask[i]));
|
||||||
}
|
}
|
||||||
@ -12992,7 +12992,7 @@ bool InstCombiner::DoOneIteration(Function &F, unsigned Iteration) {
|
|||||||
Changed = true;
|
Changed = true;
|
||||||
}
|
}
|
||||||
if (!I->use_empty())
|
if (!I->use_empty())
|
||||||
I->replaceAllUsesWith(Context->getUndef(I->getType()));
|
I->replaceAllUsesWith(UndefValue::get(I->getType()));
|
||||||
I->eraseFromParent();
|
I->eraseFromParent();
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -564,8 +564,7 @@ bool JumpThreading::SimplifyPartiallyRedundantLoad(LoadInst *LI) {
|
|||||||
|
|
||||||
// If the returned value is the load itself, replace with an undef. This can
|
// If the returned value is the load itself, replace with an undef. This can
|
||||||
// only happen in dead loops.
|
// only happen in dead loops.
|
||||||
if (AvailableVal == LI) AvailableVal =
|
if (AvailableVal == LI) AvailableVal = UndefValue::get(LI->getType());
|
||||||
AvailableVal->getContext().getUndef(LI->getType());
|
|
||||||
LI->replaceAllUsesWith(AvailableVal);
|
LI->replaceAllUsesWith(AvailableVal);
|
||||||
LI->eraseFromParent();
|
LI->eraseFromParent();
|
||||||
return true;
|
return true;
|
||||||
|
@ -486,7 +486,7 @@ void LICM::sink(Instruction &I) {
|
|||||||
// Instruction is not used, just delete it.
|
// Instruction is not used, just delete it.
|
||||||
CurAST->deleteValue(&I);
|
CurAST->deleteValue(&I);
|
||||||
if (!I.use_empty()) // If I has users in unreachable blocks, eliminate.
|
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();
|
I.eraseFromParent();
|
||||||
} else {
|
} else {
|
||||||
// Move the instruction to the start of the exit block, after any PHI
|
// Move the instruction to the start of the exit block, after any PHI
|
||||||
@ -500,7 +500,7 @@ void LICM::sink(Instruction &I) {
|
|||||||
// The instruction is actually dead if there ARE NO exit blocks.
|
// The instruction is actually dead if there ARE NO exit blocks.
|
||||||
CurAST->deleteValue(&I);
|
CurAST->deleteValue(&I);
|
||||||
if (!I.use_empty()) // If I has users in unreachable blocks, eliminate.
|
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();
|
I.eraseFromParent();
|
||||||
} else {
|
} else {
|
||||||
// Otherwise, if we have multiple exits, use the PromoteMem2Reg function to
|
// Otherwise, if we have multiple exits, use the PromoteMem2Reg function to
|
||||||
|
@ -821,7 +821,7 @@ void LoopUnswitch::RemoveBlockIfDead(BasicBlock *BB,
|
|||||||
// Anything that uses the instructions in this basic block should have their
|
// Anything that uses the instructions in this basic block should have their
|
||||||
// uses replaced with undefs.
|
// uses replaced with undefs.
|
||||||
if (!I->use_empty())
|
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
|
// If this is the edge to the header block for a loop, remove the loop and
|
||||||
|
@ -285,8 +285,8 @@ void Reassociate::LinearizeExprTree(BinaryOperator *I,
|
|||||||
Ops.push_back(ValueEntry(getRank(RHS), RHS));
|
Ops.push_back(ValueEntry(getRank(RHS), RHS));
|
||||||
|
|
||||||
// Clear the leaves out.
|
// Clear the leaves out.
|
||||||
I->setOperand(0, Context.getUndef(I->getType()));
|
I->setOperand(0, UndefValue::get(I->getType()));
|
||||||
I->setOperand(1, Context.getUndef(I->getType()));
|
I->setOperand(1, UndefValue::get(I->getType()));
|
||||||
return;
|
return;
|
||||||
} else {
|
} else {
|
||||||
// Turn X+(Y+Z) -> (Y+Z)+X
|
// Turn X+(Y+Z) -> (Y+Z)+X
|
||||||
@ -321,7 +321,7 @@ void Reassociate::LinearizeExprTree(BinaryOperator *I,
|
|||||||
Ops.push_back(ValueEntry(getRank(RHS), RHS));
|
Ops.push_back(ValueEntry(getRank(RHS), RHS));
|
||||||
|
|
||||||
// Clear the RHS leaf out.
|
// 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
|
// RewriteExprTree - Now that the operands for this expression tree are
|
||||||
|
@ -1578,7 +1578,7 @@ bool SCCP::runOnFunction(Function &F) {
|
|||||||
Instruction *I = Insts.back();
|
Instruction *I = Insts.back();
|
||||||
Insts.pop_back();
|
Insts.pop_back();
|
||||||
if (!I->use_empty())
|
if (!I->use_empty())
|
||||||
I->replaceAllUsesWith(F.getContext().getUndef(I->getType()));
|
I->replaceAllUsesWith(UndefValue::get(I->getType()));
|
||||||
BB->getInstList().erase(I);
|
BB->getInstList().erase(I);
|
||||||
MadeChanges = true;
|
MadeChanges = true;
|
||||||
++NumInstRemoved;
|
++NumInstRemoved;
|
||||||
@ -1598,7 +1598,7 @@ bool SCCP::runOnFunction(Function &F) {
|
|||||||
continue;
|
continue;
|
||||||
|
|
||||||
Constant *Const = IV.isConstant()
|
Constant *Const = IV.isConstant()
|
||||||
? IV.getConstant() : F.getContext().getUndef(Inst->getType());
|
? IV.getConstant() : UndefValue::get(Inst->getType());
|
||||||
DEBUG(errs() << " Constant: " << *Const << " = " << *Inst);
|
DEBUG(errs() << " Constant: " << *Const << " = " << *Inst);
|
||||||
|
|
||||||
// Replaces all of the uses of a variable with uses of the constant.
|
// Replaces all of the uses of a variable with uses of the constant.
|
||||||
@ -1717,7 +1717,7 @@ bool IPSCCP::runOnModule(Module &M) {
|
|||||||
LatticeVal &IV = Values[AI];
|
LatticeVal &IV = Values[AI];
|
||||||
if (IV.isConstant() || IV.isUndefined()) {
|
if (IV.isConstant() || IV.isUndefined()) {
|
||||||
Constant *CST = IV.isConstant() ?
|
Constant *CST = IV.isConstant() ?
|
||||||
IV.getConstant() : Context->getUndef(AI->getType());
|
IV.getConstant() : UndefValue::get(AI->getType());
|
||||||
DEBUG(errs() << "*** Arg " << *AI << " = " << *CST <<"\n");
|
DEBUG(errs() << "*** Arg " << *AI << " = " << *CST <<"\n");
|
||||||
|
|
||||||
// Replaces all of the uses of a variable with uses of the
|
// Replaces all of the uses of a variable with uses of the
|
||||||
@ -1742,7 +1742,7 @@ bool IPSCCP::runOnModule(Module &M) {
|
|||||||
Instruction *I = Insts.back();
|
Instruction *I = Insts.back();
|
||||||
Insts.pop_back();
|
Insts.pop_back();
|
||||||
if (!I->use_empty())
|
if (!I->use_empty())
|
||||||
I->replaceAllUsesWith(Context->getUndef(I->getType()));
|
I->replaceAllUsesWith(UndefValue::get(I->getType()));
|
||||||
BB->getInstList().erase(I);
|
BB->getInstList().erase(I);
|
||||||
MadeChanges = true;
|
MadeChanges = true;
|
||||||
++IPNumInstRemoved;
|
++IPNumInstRemoved;
|
||||||
@ -1754,7 +1754,7 @@ bool IPSCCP::runOnModule(Module &M) {
|
|||||||
TI->getSuccessor(i)->removePredecessor(BB);
|
TI->getSuccessor(i)->removePredecessor(BB);
|
||||||
}
|
}
|
||||||
if (!TI->use_empty())
|
if (!TI->use_empty())
|
||||||
TI->replaceAllUsesWith(Context->getUndef(TI->getType()));
|
TI->replaceAllUsesWith(UndefValue::get(TI->getType()));
|
||||||
BB->getInstList().erase(TI);
|
BB->getInstList().erase(TI);
|
||||||
|
|
||||||
if (&*BB != &F->front())
|
if (&*BB != &F->front())
|
||||||
@ -1773,7 +1773,7 @@ bool IPSCCP::runOnModule(Module &M) {
|
|||||||
continue;
|
continue;
|
||||||
|
|
||||||
Constant *Const = IV.isConstant()
|
Constant *Const = IV.isConstant()
|
||||||
? IV.getConstant() : Context->getUndef(Inst->getType());
|
? IV.getConstant() : UndefValue::get(Inst->getType());
|
||||||
DEBUG(errs() << " Constant: " << *Const << " = " << *Inst);
|
DEBUG(errs() << " Constant: " << *Const << " = " << *Inst);
|
||||||
|
|
||||||
// Replaces all of the uses of a variable with uses of the
|
// Replaces all of the uses of a variable with uses of the
|
||||||
@ -1847,7 +1847,7 @@ bool IPSCCP::runOnModule(Module &M) {
|
|||||||
for (Function::iterator BB = F->begin(), E = F->end(); BB != E; ++BB)
|
for (Function::iterator BB = F->begin(), E = F->end(); BB != E; ++BB)
|
||||||
if (ReturnInst *RI = dyn_cast<ReturnInst>(BB->getTerminator()))
|
if (ReturnInst *RI = dyn_cast<ReturnInst>(BB->getTerminator()))
|
||||||
if (!isa<UndefValue>(RI->getOperand(0)))
|
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
|
// If we infered constant or undef values for globals variables, we can delete
|
||||||
|
@ -371,7 +371,7 @@ void SROA::DoScalarReplacement(AllocationInst *AI,
|
|||||||
// %insert = insertvalue { i32, i32 } %insert.0, i32 %load.1, 1
|
// %insert = insertvalue { i32, i32 } %insert.0, i32 %load.1, 1
|
||||||
// (Also works for arrays instead of structs)
|
// (Also works for arrays instead of structs)
|
||||||
if (LoadInst *LI = dyn_cast<LoadInst>(User)) {
|
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) {
|
for (unsigned i = 0, e = ElementAllocas.size(); i != e; ++i) {
|
||||||
Value *Load = new LoadInst(ElementAllocas[i], "load", LI);
|
Value *Load = new LoadInst(ElementAllocas[i], "load", LI);
|
||||||
Insert = InsertValueInst::Create(Insert, Load, i, "insert", LI);
|
Insert = InsertValueInst::Create(Insert, Load, i, "insert", LI);
|
||||||
@ -1540,8 +1540,6 @@ Value *SROA::ConvertScalar_ExtractValue(Value *FromVal, const Type *ToType,
|
|||||||
if (FromVal->getType() == ToType && Offset == 0)
|
if (FromVal->getType() == ToType && Offset == 0)
|
||||||
return FromVal;
|
return FromVal;
|
||||||
|
|
||||||
LLVMContext &Context = FromVal->getContext();
|
|
||||||
|
|
||||||
// If the result alloca is a vector type, this is either an element
|
// 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.
|
// access or a bitcast to another vector type of the same size.
|
||||||
if (const VectorType *VTy = dyn_cast<VectorType>(FromVal->getType())) {
|
if (const VectorType *VTy = dyn_cast<VectorType>(FromVal->getType())) {
|
||||||
@ -1568,7 +1566,7 @@ Value *SROA::ConvertScalar_ExtractValue(Value *FromVal, const Type *ToType,
|
|||||||
// use insertvalue's to form the FCA.
|
// use insertvalue's to form the FCA.
|
||||||
if (const StructType *ST = dyn_cast<StructType>(ToType)) {
|
if (const StructType *ST = dyn_cast<StructType>(ToType)) {
|
||||||
const StructLayout &Layout = *TD->getStructLayout(ST);
|
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) {
|
for (unsigned i = 0, e = ST->getNumElements(); i != e; ++i) {
|
||||||
Value *Elt = ConvertScalar_ExtractValue(FromVal, ST->getElementType(i),
|
Value *Elt = ConvertScalar_ExtractValue(FromVal, ST->getElementType(i),
|
||||||
Offset+Layout.getElementOffsetInBits(i),
|
Offset+Layout.getElementOffsetInBits(i),
|
||||||
@ -1580,7 +1578,7 @@ Value *SROA::ConvertScalar_ExtractValue(Value *FromVal, const Type *ToType,
|
|||||||
|
|
||||||
if (const ArrayType *AT = dyn_cast<ArrayType>(ToType)) {
|
if (const ArrayType *AT = dyn_cast<ArrayType>(ToType)) {
|
||||||
uint64_t EltSize = TD->getTypeAllocSizeInBits(AT->getElementType());
|
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) {
|
for (unsigned i = 0, e = AT->getNumElements(); i != e; ++i) {
|
||||||
Value *Elt = ConvertScalar_ExtractValue(FromVal, AT->getElementType(),
|
Value *Elt = ConvertScalar_ExtractValue(FromVal, AT->getElementType(),
|
||||||
Offset+i*EltSize, Builder);
|
Offset+i*EltSize, Builder);
|
||||||
|
@ -71,7 +71,7 @@ static void ChangeToUnreachable(Instruction *I, LLVMContext &Context) {
|
|||||||
BasicBlock::iterator BBI = I, BBE = BB->end();
|
BasicBlock::iterator BBI = I, BBE = BB->end();
|
||||||
while (BBI != BBE) {
|
while (BBI != BBE) {
|
||||||
if (!BBI->use_empty())
|
if (!BBI->use_empty())
|
||||||
BBI->replaceAllUsesWith(Context.getUndef(BBI->getType()));
|
BBI->replaceAllUsesWith(UndefValue::get(BBI->getType()));
|
||||||
BB->getInstList().erase(BBI++);
|
BB->getInstList().erase(BBI++);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -51,7 +51,7 @@ void llvm::DeleteDeadBlock(BasicBlock *BB) {
|
|||||||
// contained within it must dominate their uses, that all uses will
|
// contained within it must dominate their uses, that all uses will
|
||||||
// eventually be removed (they are themselves dead).
|
// eventually be removed (they are themselves dead).
|
||||||
if (!I.use_empty())
|
if (!I.use_empty())
|
||||||
I.replaceAllUsesWith(BB->getContext().getUndef(I.getType()));
|
I.replaceAllUsesWith(UndefValue::get(I.getType()));
|
||||||
BB->getInstList().pop_back();
|
BB->getInstList().pop_back();
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -71,7 +71,7 @@ void llvm::FoldSingleEntryPHINodes(BasicBlock *BB) {
|
|||||||
if (PN->getIncomingValue(0) != PN)
|
if (PN->getIncomingValue(0) != PN)
|
||||||
PN->replaceAllUsesWith(PN->getIncomingValue(0));
|
PN->replaceAllUsesWith(PN->getIncomingValue(0));
|
||||||
else
|
else
|
||||||
PN->replaceAllUsesWith(BB->getContext().getUndef(PN->getType()));
|
PN->replaceAllUsesWith(UndefValue::get(PN->getType()));
|
||||||
PN->eraseFromParent();
|
PN->eraseFromParent();
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -387,8 +387,7 @@ BasicBlock *llvm::SplitBlockPredecessors(BasicBlock *BB,
|
|||||||
if (NumPreds == 0) {
|
if (NumPreds == 0) {
|
||||||
// Insert dummy values as the incoming value.
|
// Insert dummy values as the incoming value.
|
||||||
for (BasicBlock::iterator I = BB->begin(); isa<PHINode>(I); ++I)
|
for (BasicBlock::iterator I = BB->begin(); isa<PHINode>(I); ++I)
|
||||||
cast<PHINode>(I)->addIncoming(BB->getContext().getUndef(I->getType()),
|
cast<PHINode>(I)->addIncoming(UndefValue::get(I->getType()), NewBB);
|
||||||
NewBB);
|
|
||||||
return NewBB;
|
return NewBB;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -489,7 +489,7 @@ void llvm::CloneAndPruneFunctionInto(Function *NewFunc, const Function *OldFunc,
|
|||||||
BasicBlock::iterator I = NewBB->begin();
|
BasicBlock::iterator I = NewBB->begin();
|
||||||
BasicBlock::const_iterator OldI = OldBB->begin();
|
BasicBlock::const_iterator OldI = OldBB->begin();
|
||||||
while ((PN = dyn_cast<PHINode>(I++))) {
|
while ((PN = dyn_cast<PHINode>(I++))) {
|
||||||
Value *NV = OldFunc->getContext().getUndef(PN->getType());
|
Value *NV = UndefValue::get(PN->getType());
|
||||||
PN->replaceAllUsesWith(NV);
|
PN->replaceAllUsesWith(NV);
|
||||||
assert(ValueMap[OldI] == PN && "ValueMap mismatch");
|
assert(ValueMap[OldI] == PN && "ValueMap mismatch");
|
||||||
ValueMap[OldI] = NV;
|
ValueMap[OldI] = NV;
|
||||||
|
@ -521,7 +521,7 @@ bool llvm::InlineFunction(CallSite CS, CallGraph *CG, const TargetData *TD) {
|
|||||||
if (!TheCall->use_empty()) {
|
if (!TheCall->use_empty()) {
|
||||||
ReturnInst *R = Returns[0];
|
ReturnInst *R = Returns[0];
|
||||||
if (TheCall == R->getReturnValue())
|
if (TheCall == R->getReturnValue())
|
||||||
TheCall->replaceAllUsesWith(Context.getUndef(TheCall->getType()));
|
TheCall->replaceAllUsesWith(UndefValue::get(TheCall->getType()));
|
||||||
else
|
else
|
||||||
TheCall->replaceAllUsesWith(R->getReturnValue());
|
TheCall->replaceAllUsesWith(R->getReturnValue());
|
||||||
}
|
}
|
||||||
@ -614,7 +614,7 @@ bool llvm::InlineFunction(CallSite CS, CallGraph *CG, const TargetData *TD) {
|
|||||||
// using the return value of the call with the computed value.
|
// using the return value of the call with the computed value.
|
||||||
if (!TheCall->use_empty()) {
|
if (!TheCall->use_empty()) {
|
||||||
if (TheCall == Returns[0]->getReturnValue())
|
if (TheCall == Returns[0]->getReturnValue())
|
||||||
TheCall->replaceAllUsesWith(Context.getUndef(TheCall->getType()));
|
TheCall->replaceAllUsesWith(UndefValue::get(TheCall->getType()));
|
||||||
else
|
else
|
||||||
TheCall->replaceAllUsesWith(Returns[0]->getReturnValue());
|
TheCall->replaceAllUsesWith(Returns[0]->getReturnValue());
|
||||||
}
|
}
|
||||||
@ -634,7 +634,7 @@ bool llvm::InlineFunction(CallSite CS, CallGraph *CG, const TargetData *TD) {
|
|||||||
} else if (!TheCall->use_empty()) {
|
} else if (!TheCall->use_empty()) {
|
||||||
// No returns, but something is using the return value of the call. Just
|
// No returns, but something is using the return value of the call. Just
|
||||||
// nuke the result.
|
// 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.
|
// Since we are now done with the Call/Invoke, we can delete it.
|
||||||
|
@ -243,7 +243,7 @@ Value *LCSSA::GetValueForBlock(DomTreeNode *BB, Instruction *OrigInst,
|
|||||||
DenseMap<DomTreeNode*, Value*> &Phis) {
|
DenseMap<DomTreeNode*, Value*> &Phis) {
|
||||||
// If there is no dominator info for this BB, it is unreachable.
|
// If there is no dominator info for this BB, it is unreachable.
|
||||||
if (BB == 0)
|
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 we have already computed this value, return the previously computed val.
|
||||||
if (Phis.count(BB)) return Phis[BB];
|
if (Phis.count(BB)) return Phis[BB];
|
||||||
|
@ -263,8 +263,6 @@ void llvm::RecursivelyDeleteTriviallyDeadInstructions(Value *V) {
|
|||||||
/// too, recursively.
|
/// too, recursively.
|
||||||
void
|
void
|
||||||
llvm::RecursivelyDeleteDeadPHINode(PHINode *PN) {
|
llvm::RecursivelyDeleteDeadPHINode(PHINode *PN) {
|
||||||
LLVMContext &Context = PN->getContext();
|
|
||||||
|
|
||||||
// We can remove a PHI if it is on a cycle in the def-use graph
|
// 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,
|
// where each node in the cycle has degree one, i.e. only one use,
|
||||||
// and is an instruction with no side effects.
|
// and is an instruction with no side effects.
|
||||||
@ -281,7 +279,7 @@ llvm::RecursivelyDeleteDeadPHINode(PHINode *PN) {
|
|||||||
if (PHINode *JP = dyn_cast<PHINode>(J))
|
if (PHINode *JP = dyn_cast<PHINode>(J))
|
||||||
if (!PHIs.insert(cast<PHINode>(JP))) {
|
if (!PHIs.insert(cast<PHINode>(JP))) {
|
||||||
// Break the cycle and delete the PHI and its operands.
|
// Break the cycle and delete the PHI and its operands.
|
||||||
JP->replaceAllUsesWith(Context.getUndef(JP->getType()));
|
JP->replaceAllUsesWith(UndefValue::get(JP->getType()));
|
||||||
RecursivelyDeleteTriviallyDeadInstructions(JP);
|
RecursivelyDeleteTriviallyDeadInstructions(JP);
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
@ -301,7 +299,7 @@ void llvm::MergeBasicBlockIntoOnlyPred(BasicBlock *DestBB) {
|
|||||||
while (PHINode *PN = dyn_cast<PHINode>(DestBB->begin())) {
|
while (PHINode *PN = dyn_cast<PHINode>(DestBB->begin())) {
|
||||||
Value *NewVal = PN->getIncomingValue(0);
|
Value *NewVal = PN->getIncomingValue(0);
|
||||||
// Replace self referencing PHI with undef, it must be dead.
|
// 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->replaceAllUsesWith(NewVal);
|
||||||
PN->eraseFromParent();
|
PN->eraseFromParent();
|
||||||
}
|
}
|
||||||
|
@ -166,7 +166,7 @@ bool LoopSimplify::runOnFunction(Function &F) {
|
|||||||
// Delete the dead terminator.
|
// Delete the dead terminator.
|
||||||
if (AA) AA->deleteValue(TI);
|
if (AA) AA->deleteValue(TI);
|
||||||
if (!TI->use_empty())
|
if (!TI->use_empty())
|
||||||
TI->replaceAllUsesWith(F.getContext().getUndef(TI->getType()));
|
TI->replaceAllUsesWith(UndefValue::get(TI->getType()));
|
||||||
TI->eraseFromParent();
|
TI->eraseFromParent();
|
||||||
Changed |= true;
|
Changed |= true;
|
||||||
}
|
}
|
||||||
|
@ -448,7 +448,7 @@ void PromoteMem2Reg::run() {
|
|||||||
//
|
//
|
||||||
RenamePassData::ValVector Values(Allocas.size());
|
RenamePassData::ValVector Values(Allocas.size());
|
||||||
for (unsigned i = 0, e = Allocas.size(); i != e; ++i)
|
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
|
// Walks all basic blocks in the function performing the SSA rename algorithm
|
||||||
// and inserting the phi nodes we marked as necessary
|
// and inserting the phi nodes we marked as necessary
|
||||||
@ -475,7 +475,7 @@ void PromoteMem2Reg::run() {
|
|||||||
// Just delete the users now.
|
// Just delete the users now.
|
||||||
//
|
//
|
||||||
if (!A->use_empty())
|
if (!A->use_empty())
|
||||||
A->replaceAllUsesWith(Context.getUndef(A->getType()));
|
A->replaceAllUsesWith(UndefValue::get(A->getType()));
|
||||||
if (AST) AST->deleteValue(A);
|
if (AST) AST->deleteValue(A);
|
||||||
A->eraseFromParent();
|
A->eraseFromParent();
|
||||||
}
|
}
|
||||||
@ -561,7 +561,7 @@ void PromoteMem2Reg::run() {
|
|||||||
BasicBlock::iterator BBI = BB->begin();
|
BasicBlock::iterator BBI = BB->begin();
|
||||||
while ((SomePHI = dyn_cast<PHINode>(BBI++)) &&
|
while ((SomePHI = dyn_cast<PHINode>(BBI++)) &&
|
||||||
SomePHI->getNumIncomingValues() == NumBadPreds) {
|
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)
|
for (unsigned pred = 0, e = Preds.size(); pred != e; ++pred)
|
||||||
SomePHI->addIncoming(UndefVal, Preds[pred]);
|
SomePHI->addIncoming(UndefVal, Preds[pred]);
|
||||||
}
|
}
|
||||||
@ -807,7 +807,7 @@ void PromoteMem2Reg::PromoteSingleBlockAlloca(AllocaInst *AI, AllocaInfo &Info,
|
|||||||
if (StoresByIndex.empty()) {
|
if (StoresByIndex.empty()) {
|
||||||
for (Value::use_iterator UI = AI->use_begin(), E = AI->use_end(); UI != E;)
|
for (Value::use_iterator UI = AI->use_begin(), E = AI->use_end(); UI != E;)
|
||||||
if (LoadInst *LI = dyn_cast<LoadInst>(*UI++)) {
|
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()))
|
if (AST && isa<PointerType>(LI->getType()))
|
||||||
AST->deleteValue(LI);
|
AST->deleteValue(LI);
|
||||||
LBI.deleteValue(LI);
|
LBI.deleteValue(LI);
|
||||||
|
@ -1266,8 +1266,6 @@ static bool FoldCondBranchOnPHI(BranchInst *BI) {
|
|||||||
/// FoldTwoEntryPHINode - Given a BB that starts with the specified two-entry
|
/// FoldTwoEntryPHINode - Given a BB that starts with the specified two-entry
|
||||||
/// PHI node, see if we can eliminate it.
|
/// PHI node, see if we can eliminate it.
|
||||||
static bool FoldTwoEntryPHINode(PHINode *PN) {
|
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
|
// 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
|
// statement", which has a very simple dominance structure. Basically, we
|
||||||
// are trying to find the condition that is being branched on, which
|
// are trying to find the condition that is being branched on, which
|
||||||
@ -1305,7 +1303,7 @@ static bool FoldTwoEntryPHINode(PHINode *PN) {
|
|||||||
if (PN->getIncomingValue(0) != PN)
|
if (PN->getIncomingValue(0) != PN)
|
||||||
PN->replaceAllUsesWith(PN->getIncomingValue(0));
|
PN->replaceAllUsesWith(PN->getIncomingValue(0));
|
||||||
else
|
else
|
||||||
PN->replaceAllUsesWith(Context.getUndef(PN->getType()));
|
PN->replaceAllUsesWith(UndefValue::get(PN->getType()));
|
||||||
} else if (!DominatesMergePoint(PN->getIncomingValue(0), BB,
|
} else if (!DominatesMergePoint(PN->getIncomingValue(0), BB,
|
||||||
&AggressiveInsts) ||
|
&AggressiveInsts) ||
|
||||||
!DominatesMergePoint(PN->getIncomingValue(1), BB,
|
!DominatesMergePoint(PN->getIncomingValue(1), BB,
|
||||||
|
@ -230,7 +230,6 @@ bool llvm::UpgradeIntrinsicFunction(Function *F, Function *&NewFn) {
|
|||||||
// order to seamlessly integrate with existing context.
|
// order to seamlessly integrate with existing context.
|
||||||
void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) {
|
void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) {
|
||||||
Function *F = CI->getCalledFunction();
|
Function *F = CI->getCalledFunction();
|
||||||
LLVMContext &Context = F->getContext();
|
|
||||||
|
|
||||||
assert(F && "CallInst has no function associated with it.");
|
assert(F && "CallInst has no function associated with it.");
|
||||||
|
|
||||||
@ -264,7 +263,7 @@ void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) {
|
|||||||
Value *Op0 = CI->getOperand(1);
|
Value *Op0 = CI->getOperand(1);
|
||||||
ShuffleVectorInst *SI = NULL;
|
ShuffleVectorInst *SI = NULL;
|
||||||
if (isLoadH || isLoadL) {
|
if (isLoadH || isLoadL) {
|
||||||
Value *Op1 = Context.getUndef(Op0->getType());
|
Value *Op1 = UndefValue::get(Op0->getType());
|
||||||
Value *Addr = new BitCastInst(CI->getOperand(2),
|
Value *Addr = new BitCastInst(CI->getOperand(2),
|
||||||
PointerType::getUnqual(Type::DoubleTy),
|
PointerType::getUnqual(Type::DoubleTy),
|
||||||
"upgraded.", CI);
|
"upgraded.", CI);
|
||||||
|
@ -203,7 +203,7 @@ void BasicBlock::removePredecessor(BasicBlock *Pred,
|
|||||||
PN->replaceAllUsesWith(PN->getOperand(0));
|
PN->replaceAllUsesWith(PN->getOperand(0));
|
||||||
else
|
else
|
||||||
// We are left with an infinite loop with no entries: kill the PHI.
|
// 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
|
getInstList().pop_front(); // Remove the PHI node
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -151,7 +151,7 @@ static Constant *FoldBitCast(LLVMContext &Context,
|
|||||||
// Finally, implement bitcast folding now. The code below doesn't handle
|
// Finally, implement bitcast folding now. The code below doesn't handle
|
||||||
// bitcast right.
|
// bitcast right.
|
||||||
if (isa<ConstantPointerNull>(V)) // ptr->ptr cast.
|
if (isa<ConstantPointerNull>(V)) // ptr->ptr cast.
|
||||||
return Context.getConstantPointerNull(cast<PointerType>(DestTy));
|
return ConstantPointerNull::get(cast<PointerType>(DestTy));
|
||||||
|
|
||||||
// Handle integral constant input.
|
// Handle integral constant input.
|
||||||
if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
|
if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
|
||||||
@ -187,7 +187,7 @@ Constant *llvm::ConstantFoldCastInstruction(LLVMContext &Context,
|
|||||||
if (opc == Instruction::ZExt || opc == Instruction::SExt ||
|
if (opc == Instruction::ZExt || opc == Instruction::SExt ||
|
||||||
opc == Instruction::UIToFP || opc == Instruction::SIToFP)
|
opc == Instruction::UIToFP || opc == Instruction::SIToFP)
|
||||||
return Context.getNullValue(DestTy);
|
return Context.getNullValue(DestTy);
|
||||||
return Context.getUndef(DestTy);
|
return UndefValue::get(DestTy);
|
||||||
}
|
}
|
||||||
// No compile-time operations on this type yet.
|
// No compile-time operations on this type yet.
|
||||||
if (V->getType() == Type::PPC_FP128Ty || DestTy == Type::PPC_FP128Ty)
|
if (V->getType() == Type::PPC_FP128Ty || DestTy == Type::PPC_FP128Ty)
|
||||||
@ -263,7 +263,7 @@ Constant *llvm::ConstantFoldCastInstruction(LLVMContext &Context,
|
|||||||
return 0; // Can't fold.
|
return 0; // Can't fold.
|
||||||
case Instruction::IntToPtr: //always treated as unsigned
|
case Instruction::IntToPtr: //always treated as unsigned
|
||||||
if (V->isNullValue()) // Is it an integral null value?
|
if (V->isNullValue()) // Is it an integral null value?
|
||||||
return Context.getConstantPointerNull(cast<PointerType>(DestTy));
|
return ConstantPointerNull::get(cast<PointerType>(DestTy));
|
||||||
return 0; // Other pointer types cannot be casted
|
return 0; // Other pointer types cannot be casted
|
||||||
case Instruction::PtrToInt: // always treated as unsigned
|
case Instruction::PtrToInt: // always treated as unsigned
|
||||||
if (V->isNullValue()) // is it a null pointer value?
|
if (V->isNullValue()) // is it a null pointer value?
|
||||||
@ -335,7 +335,7 @@ Constant *llvm::ConstantFoldExtractElementInstruction(LLVMContext &Context,
|
|||||||
const Constant *Val,
|
const Constant *Val,
|
||||||
const Constant *Idx) {
|
const Constant *Idx) {
|
||||||
if (isa<UndefValue>(Val)) // ee(undef, x) -> undef
|
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
|
if (Val->isNullValue()) // ee(zero, x) -> zero
|
||||||
return Context.getNullValue(
|
return Context.getNullValue(
|
||||||
cast<VectorType>(Val->getType())->getElementType());
|
cast<VectorType>(Val->getType())->getElementType());
|
||||||
@ -371,7 +371,7 @@ Constant *llvm::ConstantFoldInsertElementInstruction(LLVMContext &Context,
|
|||||||
Ops.reserve(numOps);
|
Ops.reserve(numOps);
|
||||||
for (unsigned i = 0; i < numOps; ++i) {
|
for (unsigned i = 0; i < numOps; ++i) {
|
||||||
const Constant *Op =
|
const Constant *Op =
|
||||||
(idxVal == i) ? Elt : Context.getUndef(Elt->getType());
|
(idxVal == i) ? Elt : UndefValue::get(Elt->getType());
|
||||||
Ops.push_back(const_cast<Constant*>(Op));
|
Ops.push_back(const_cast<Constant*>(Op));
|
||||||
}
|
}
|
||||||
return ConstantVector::get(Ops);
|
return ConstantVector::get(Ops);
|
||||||
@ -420,7 +420,7 @@ static Constant *GetVectorElement(LLVMContext &Context, const Constant *C,
|
|||||||
if (isa<ConstantAggregateZero>(C))
|
if (isa<ConstantAggregateZero>(C))
|
||||||
return Context.getNullValue(EltTy);
|
return Context.getNullValue(EltTy);
|
||||||
if (isa<UndefValue>(C))
|
if (isa<UndefValue>(C))
|
||||||
return Context.getUndef(EltTy);
|
return UndefValue::get(EltTy);
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -429,7 +429,7 @@ Constant *llvm::ConstantFoldShuffleVectorInstruction(LLVMContext &Context,
|
|||||||
const Constant *V2,
|
const Constant *V2,
|
||||||
const Constant *Mask) {
|
const Constant *Mask) {
|
||||||
// Undefined shuffle mask -> undefined value.
|
// 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 MaskNumElts = cast<VectorType>(Mask->getType())->getNumElements();
|
||||||
unsigned SrcNumElts = cast<VectorType>(V1->getType())->getNumElements();
|
unsigned SrcNumElts = cast<VectorType>(V1->getType())->getNumElements();
|
||||||
@ -442,11 +442,11 @@ Constant *llvm::ConstantFoldShuffleVectorInstruction(LLVMContext &Context,
|
|||||||
if (InElt == 0) return 0;
|
if (InElt == 0) return 0;
|
||||||
|
|
||||||
if (isa<UndefValue>(InElt))
|
if (isa<UndefValue>(InElt))
|
||||||
InElt = Context.getUndef(EltTy);
|
InElt = UndefValue::get(EltTy);
|
||||||
else if (ConstantInt *CI = dyn_cast<ConstantInt>(InElt)) {
|
else if (ConstantInt *CI = dyn_cast<ConstantInt>(InElt)) {
|
||||||
unsigned Elt = CI->getZExtValue();
|
unsigned Elt = CI->getZExtValue();
|
||||||
if (Elt >= SrcNumElts*2)
|
if (Elt >= SrcNumElts*2)
|
||||||
InElt = Context.getUndef(EltTy);
|
InElt = UndefValue::get(EltTy);
|
||||||
else if (Elt >= SrcNumElts)
|
else if (Elt >= SrcNumElts)
|
||||||
InElt = GetVectorElement(Context, V2, Elt - SrcNumElts);
|
InElt = GetVectorElement(Context, V2, Elt - SrcNumElts);
|
||||||
else
|
else
|
||||||
@ -471,7 +471,7 @@ Constant *llvm::ConstantFoldExtractValueInstruction(LLVMContext &Context,
|
|||||||
return const_cast<Constant *>(Agg);
|
return const_cast<Constant *>(Agg);
|
||||||
|
|
||||||
if (isa<UndefValue>(Agg)) // ev(undef, x) -> undef
|
if (isa<UndefValue>(Agg)) // ev(undef, x) -> undef
|
||||||
return Context.getUndef(ExtractValueInst::getIndexedType(Agg->getType(),
|
return UndefValue::get(ExtractValueInst::getIndexedType(Agg->getType(),
|
||||||
Idxs,
|
Idxs,
|
||||||
Idxs + NumIdx));
|
Idxs + NumIdx));
|
||||||
|
|
||||||
@ -513,9 +513,9 @@ Constant *llvm::ConstantFoldInsertValueInstruction(LLVMContext &Context,
|
|||||||
const Type *MemberTy = AggTy->getTypeAtIndex(i);
|
const Type *MemberTy = AggTy->getTypeAtIndex(i);
|
||||||
const Constant *Op =
|
const Constant *Op =
|
||||||
(*Idxs == i) ?
|
(*Idxs == i) ?
|
||||||
ConstantFoldInsertValueInstruction(Context, Context.getUndef(MemberTy),
|
ConstantFoldInsertValueInstruction(Context, UndefValue::get(MemberTy),
|
||||||
Val, Idxs+1, NumIdx-1) :
|
Val, Idxs+1, NumIdx-1) :
|
||||||
Context.getUndef(MemberTy);
|
UndefValue::get(MemberTy);
|
||||||
Ops[i] = const_cast<Constant*>(Op);
|
Ops[i] = const_cast<Constant*>(Op);
|
||||||
}
|
}
|
||||||
if (isa<StructType>(AggTy))
|
if (isa<StructType>(AggTy))
|
||||||
@ -594,7 +594,7 @@ Constant *llvm::ConstantFoldBinaryInstruction(LLVMContext &Context,
|
|||||||
// Fallthrough
|
// Fallthrough
|
||||||
case Instruction::Add:
|
case Instruction::Add:
|
||||||
case Instruction::Sub:
|
case Instruction::Sub:
|
||||||
return Context.getUndef(C1->getType());
|
return UndefValue::get(C1->getType());
|
||||||
case Instruction::Mul:
|
case Instruction::Mul:
|
||||||
case Instruction::And:
|
case Instruction::And:
|
||||||
return Context.getNullValue(C1->getType());
|
return Context.getNullValue(C1->getType());
|
||||||
@ -646,14 +646,14 @@ Constant *llvm::ConstantFoldBinaryInstruction(LLVMContext &Context,
|
|||||||
if (CI2->equalsInt(1))
|
if (CI2->equalsInt(1))
|
||||||
return const_cast<Constant*>(C1); // X / 1 == X
|
return const_cast<Constant*>(C1); // X / 1 == X
|
||||||
if (CI2->equalsInt(0))
|
if (CI2->equalsInt(0))
|
||||||
return Context.getUndef(CI2->getType()); // X / 0 == undef
|
return UndefValue::get(CI2->getType()); // X / 0 == undef
|
||||||
break;
|
break;
|
||||||
case Instruction::URem:
|
case Instruction::URem:
|
||||||
case Instruction::SRem:
|
case Instruction::SRem:
|
||||||
if (CI2->equalsInt(1))
|
if (CI2->equalsInt(1))
|
||||||
return Context.getNullValue(CI2->getType()); // X % 1 == 0
|
return Context.getNullValue(CI2->getType()); // X % 1 == 0
|
||||||
if (CI2->equalsInt(0))
|
if (CI2->equalsInt(0))
|
||||||
return Context.getUndef(CI2->getType()); // X % 0 == undef
|
return UndefValue::get(CI2->getType()); // X % 0 == undef
|
||||||
break;
|
break;
|
||||||
case Instruction::And:
|
case Instruction::And:
|
||||||
if (CI2->isZero()) return const_cast<Constant*>(C2); // X & 0 == 0
|
if (CI2->isZero()) return const_cast<Constant*>(C2); // X & 0 == 0
|
||||||
@ -732,7 +732,7 @@ Constant *llvm::ConstantFoldBinaryInstruction(LLVMContext &Context,
|
|||||||
case Instruction::SDiv:
|
case Instruction::SDiv:
|
||||||
assert(!CI2->isNullValue() && "Div by zero handled above");
|
assert(!CI2->isNullValue() && "Div by zero handled above");
|
||||||
if (C2V.isAllOnesValue() && C1V.isMinSignedValue())
|
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));
|
return ConstantInt::get(Context, C1V.sdiv(C2V));
|
||||||
case Instruction::URem:
|
case Instruction::URem:
|
||||||
assert(!CI2->isNullValue() && "Div by zero handled above");
|
assert(!CI2->isNullValue() && "Div by zero handled above");
|
||||||
@ -740,7 +740,7 @@ Constant *llvm::ConstantFoldBinaryInstruction(LLVMContext &Context,
|
|||||||
case Instruction::SRem:
|
case Instruction::SRem:
|
||||||
assert(!CI2->isNullValue() && "Div by zero handled above");
|
assert(!CI2->isNullValue() && "Div by zero handled above");
|
||||||
if (C2V.isAllOnesValue() && C1V.isMinSignedValue())
|
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));
|
return ConstantInt::get(Context, C1V.srem(C2V));
|
||||||
case Instruction::And:
|
case Instruction::And:
|
||||||
return ConstantInt::get(Context, C1V & C2V);
|
return ConstantInt::get(Context, C1V & C2V);
|
||||||
@ -753,21 +753,21 @@ Constant *llvm::ConstantFoldBinaryInstruction(LLVMContext &Context,
|
|||||||
if (shiftAmt < C1V.getBitWidth())
|
if (shiftAmt < C1V.getBitWidth())
|
||||||
return ConstantInt::get(Context, C1V.shl(shiftAmt));
|
return ConstantInt::get(Context, C1V.shl(shiftAmt));
|
||||||
else
|
else
|
||||||
return Context.getUndef(C1->getType()); // too big shift is undef
|
return UndefValue::get(C1->getType()); // too big shift is undef
|
||||||
}
|
}
|
||||||
case Instruction::LShr: {
|
case Instruction::LShr: {
|
||||||
uint32_t shiftAmt = C2V.getZExtValue();
|
uint32_t shiftAmt = C2V.getZExtValue();
|
||||||
if (shiftAmt < C1V.getBitWidth())
|
if (shiftAmt < C1V.getBitWidth())
|
||||||
return ConstantInt::get(Context, C1V.lshr(shiftAmt));
|
return ConstantInt::get(Context, C1V.lshr(shiftAmt));
|
||||||
else
|
else
|
||||||
return Context.getUndef(C1->getType()); // too big shift is undef
|
return UndefValue::get(C1->getType()); // too big shift is undef
|
||||||
}
|
}
|
||||||
case Instruction::AShr: {
|
case Instruction::AShr: {
|
||||||
uint32_t shiftAmt = C2V.getZExtValue();
|
uint32_t shiftAmt = C2V.getZExtValue();
|
||||||
if (shiftAmt < C1V.getBitWidth())
|
if (shiftAmt < C1V.getBitWidth())
|
||||||
return ConstantInt::get(Context, C1V.ashr(shiftAmt));
|
return ConstantInt::get(Context, C1V.ashr(shiftAmt));
|
||||||
else
|
else
|
||||||
return Context.getUndef(C1->getType()); // too big shift is undef
|
return UndefValue::get(C1->getType()); // too big shift is undef
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -1386,7 +1386,7 @@ Constant *llvm::ConstantFoldCompareInstruction(LLVMContext &Context,
|
|||||||
|
|
||||||
// Handle some degenerate cases first
|
// Handle some degenerate cases first
|
||||||
if (isa<UndefValue>(C1) || isa<UndefValue>(C2))
|
if (isa<UndefValue>(C1) || isa<UndefValue>(C2))
|
||||||
return Context.getUndef(ResultTy);
|
return UndefValue::get(ResultTy);
|
||||||
|
|
||||||
// No compile-time operations on this type yet.
|
// No compile-time operations on this type yet.
|
||||||
if (C1->getType() == Type::PPC_FP128Ty)
|
if (C1->getType() == Type::PPC_FP128Ty)
|
||||||
@ -1677,7 +1677,7 @@ Constant *llvm::ConstantFoldGetElementPtr(LLVMContext &Context,
|
|||||||
(Value **)Idxs,
|
(Value **)Idxs,
|
||||||
(Value **)Idxs+NumIdx);
|
(Value **)Idxs+NumIdx);
|
||||||
assert(Ty != 0 && "Invalid indices for GEP!");
|
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];
|
Constant *Idx0 = Idxs[0];
|
||||||
@ -1694,7 +1694,7 @@ Constant *llvm::ConstantFoldGetElementPtr(LLVMContext &Context,
|
|||||||
(Value**)Idxs,
|
(Value**)Idxs,
|
||||||
(Value**)Idxs+NumIdx);
|
(Value**)Idxs+NumIdx);
|
||||||
assert(Ty != 0 && "Invalid indices for GEP!");
|
assert(Ty != 0 && "Invalid indices for GEP!");
|
||||||
return Context.getConstantPointerNull(
|
return ConstantPointerNull::get(
|
||||||
PointerType::get(Ty,Ptr->getAddressSpace()));
|
PointerType::get(Ty,Ptr->getAddressSpace()));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -153,7 +153,7 @@ void Constant::getVectorElements(LLVMContext &Context,
|
|||||||
}
|
}
|
||||||
|
|
||||||
if (isa<UndefValue>(this)) {
|
if (isa<UndefValue>(this)) {
|
||||||
Elts.assign(VT->getNumElements(), Context.getUndef(VT->getElementType()));
|
Elts.assign(VT->getNumElements(), UndefValue::get(VT->getElementType()));
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -391,7 +391,7 @@ Constant *ConstantArray::get(const ArrayType *Ty,
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
return Ty->getContext().getConstantAggregateZero(Ty);
|
return ConstantAggregateZero::get(Ty);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
@ -455,7 +455,7 @@ Constant* ConstantStruct::get(const StructType* T,
|
|||||||
// Implicitly locked.
|
// Implicitly locked.
|
||||||
return pImpl->StructConstants.getOrCreate(T, V);
|
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) {
|
Constant* ConstantStruct::get(const std::vector<Constant*>& V, bool packed) {
|
||||||
@ -511,9 +511,9 @@ Constant* ConstantVector::get(const VectorType* T,
|
|||||||
}
|
}
|
||||||
|
|
||||||
if (isZero)
|
if (isZero)
|
||||||
return Context.getConstantAggregateZero(T);
|
return ConstantAggregateZero::get(T);
|
||||||
if (isUndef)
|
if (isUndef)
|
||||||
return Context.getUndef(T);
|
return UndefValue::get(T);
|
||||||
|
|
||||||
// Implicitly locked.
|
// Implicitly locked.
|
||||||
return pImpl->VectorConstants.getOrCreate(T, V);
|
return pImpl->VectorConstants.getOrCreate(T, V);
|
||||||
@ -1018,11 +1018,22 @@ bool ConstantFP::isValueValidForType(const Type *Ty, const APFloat& Val) {
|
|||||||
//===----------------------------------------------------------------------===//
|
//===----------------------------------------------------------------------===//
|
||||||
// Factory Function Implementation
|
// 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...
|
/// destroyConstant - Remove the constant from the constant table...
|
||||||
///
|
///
|
||||||
void ConstantAggregateZero::destroyConstant() {
|
void ConstantAggregateZero::destroyConstant() {
|
||||||
// Implicitly locked.
|
// Implicitly locked.
|
||||||
getType()->getContext().erase(this);
|
getType()->getContext().pImpl->AggZeroConstants.remove(this);
|
||||||
destroyConstantImpl();
|
destroyConstantImpl();
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -2154,7 +2165,7 @@ void ConstantArray::replaceUsesOfWithOnConstant(Value *From, Value *To,
|
|||||||
|
|
||||||
Constant *Replacement = 0;
|
Constant *Replacement = 0;
|
||||||
if (isAllZeros) {
|
if (isAllZeros) {
|
||||||
Replacement = Context.getConstantAggregateZero(getType());
|
Replacement = ConstantAggregateZero::get(getType());
|
||||||
} else {
|
} else {
|
||||||
// Check to see if we have this array type already.
|
// Check to see if we have this array type already.
|
||||||
sys::SmartScopedWriter<true> Writer(pImpl->ConstantsLock);
|
sys::SmartScopedWriter<true> Writer(pImpl->ConstantsLock);
|
||||||
@ -2241,7 +2252,7 @@ void ConstantStruct::replaceUsesOfWithOnConstant(Value *From, Value *To,
|
|||||||
|
|
||||||
Constant *Replacement = 0;
|
Constant *Replacement = 0;
|
||||||
if (isAllZeros) {
|
if (isAllZeros) {
|
||||||
Replacement = Context.getConstantAggregateZero(getType());
|
Replacement = ConstantAggregateZero::get(getType());
|
||||||
} else {
|
} else {
|
||||||
// Check to see if we have this array type already.
|
// Check to see if we have this array type already.
|
||||||
sys::SmartScopedWriter<true> Writer(pImpl->ConstantsLock);
|
sys::SmartScopedWriter<true> Writer(pImpl->ConstantsLock);
|
||||||
|
@ -335,7 +335,7 @@ LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty) {
|
|||||||
}
|
}
|
||||||
|
|
||||||
LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty) {
|
LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty) {
|
||||||
return wrap(getGlobalContext().getUndef(unwrap(Ty)));
|
return wrap(UndefValue::get(unwrap(Ty)));
|
||||||
}
|
}
|
||||||
|
|
||||||
int LLVMIsConstant(LLVMValueRef Ty) {
|
int LLVMIsConstant(LLVMValueRef Ty) {
|
||||||
@ -354,7 +354,7 @@ int LLVMIsUndef(LLVMValueRef Val) {
|
|||||||
|
|
||||||
LLVMValueRef LLVMConstPointerNull(LLVMTypeRef Ty) {
|
LLVMValueRef LLVMConstPointerNull(LLVMTypeRef Ty) {
|
||||||
return
|
return
|
||||||
wrap(getGlobalContext().getConstantPointerNull(unwrap<PointerType>(Ty)));
|
wrap(ConstantPointerNull::get(unwrap<PointerType>(Ty)));
|
||||||
}
|
}
|
||||||
|
|
||||||
/*--.. Operations on scalar constants ......................................--*/
|
/*--.. Operations on scalar constants ......................................--*/
|
||||||
|
@ -187,7 +187,7 @@ Value *PHINode::removeIncomingValue(unsigned Idx, bool DeletePHIIfEmpty) {
|
|||||||
// If the PHI node is dead, because it has zero entries, nuke it now.
|
// If the PHI node is dead, because it has zero entries, nuke it now.
|
||||||
if (NumOps == 2 && DeletePHIIfEmpty) {
|
if (NumOps == 2 && DeletePHIIfEmpty) {
|
||||||
// If anyone is using this PHI, make them use a dummy value instead...
|
// If anyone is using this PHI, make them use a dummy value instead...
|
||||||
replaceAllUsesWith(getType()->getContext().getUndef(getType()));
|
replaceAllUsesWith(UndefValue::get(getType()));
|
||||||
eraseFromParent();
|
eraseFromParent();
|
||||||
}
|
}
|
||||||
return Removed;
|
return Removed;
|
||||||
@ -231,8 +231,7 @@ Value *PHINode::hasConstantValue(bool AllowNonDominatingInstruction) const {
|
|||||||
if (getIncomingValue(0) != this) // not X = phi X
|
if (getIncomingValue(0) != this) // not X = phi X
|
||||||
return getIncomingValue(0);
|
return getIncomingValue(0);
|
||||||
else
|
else
|
||||||
return
|
return UndefValue::get(getType()); // Self cycle is dead.
|
||||||
getType()->getContext().getUndef(getType()); // Self cycle is dead.
|
|
||||||
}
|
}
|
||||||
|
|
||||||
// Otherwise if all of the incoming values are the same for the PHI, replace
|
// Otherwise if all of the incoming values are the same for the PHI, replace
|
||||||
@ -254,7 +253,7 @@ Value *PHINode::hasConstantValue(bool AllowNonDominatingInstruction) const {
|
|||||||
// that only has entries for itself. In this case, there is no entry into the
|
// that only has entries for itself. In this case, there is no entry into the
|
||||||
// loop, so kill the PHI.
|
// 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
|
// 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
|
// instruction, we cannot always return X as the result of the PHI node. Only
|
||||||
|
@ -52,11 +52,11 @@ Constant* LLVMContext::getNullValue(const Type* Ty) {
|
|||||||
case Type::PPC_FP128TyID:
|
case Type::PPC_FP128TyID:
|
||||||
return ConstantFP::get(Ty->getContext(), APFloat(APInt(128, 2, zero)));
|
return ConstantFP::get(Ty->getContext(), APFloat(APInt(128, 2, zero)));
|
||||||
case Type::PointerTyID:
|
case Type::PointerTyID:
|
||||||
return getConstantPointerNull(cast<PointerType>(Ty));
|
return ConstantPointerNull::get(cast<PointerType>(Ty));
|
||||||
case Type::StructTyID:
|
case Type::StructTyID:
|
||||||
case Type::ArrayTyID:
|
case Type::ArrayTyID:
|
||||||
case Type::VectorTyID:
|
case Type::VectorTyID:
|
||||||
return getConstantAggregateZero(Ty);
|
return ConstantAggregateZero::get(Ty);
|
||||||
default:
|
default:
|
||||||
// Function, Label, or Opaque type?
|
// Function, Label, or Opaque type?
|
||||||
assert(!"Cannot create a null constant of that type!");
|
assert(!"Cannot create a null constant of that type!");
|
||||||
@ -75,11 +75,6 @@ Constant* LLVMContext::getAllOnesValue(const Type* Ty) {
|
|||||||
return cast<ConstantVector>(ConstantVector::get(Elts));
|
return cast<ConstantVector>(ConstantVector::get(Elts));
|
||||||
}
|
}
|
||||||
|
|
||||||
// UndefValue accessors.
|
|
||||||
UndefValue* LLVMContext::getUndef(const Type* Ty) {
|
|
||||||
return UndefValue::get(Ty);
|
|
||||||
}
|
|
||||||
|
|
||||||
// ConstantInt accessors.
|
// ConstantInt accessors.
|
||||||
ConstantInt* LLVMContext::getTrue() {
|
ConstantInt* LLVMContext::getTrue() {
|
||||||
assert(this && "Context not initialized!");
|
assert(this && "Context not initialized!");
|
||||||
@ -93,16 +88,6 @@ ConstantInt* LLVMContext::getFalse() {
|
|||||||
return pImpl->getFalse();
|
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 accessors
|
||||||
MDNode* LLVMContext::getMDNode(Value* const* Vals, unsigned NumVals) {
|
MDNode* LLVMContext::getMDNode(Value* const* Vals, unsigned NumVals) {
|
||||||
return pImpl->getMDNode(Vals, NumVals);
|
return pImpl->getMDNode(Vals, NumVals);
|
||||||
@ -120,7 +105,3 @@ void LLVMContext::erase(MDString *M) {
|
|||||||
void LLVMContext::erase(MDNode *M) {
|
void LLVMContext::erase(MDNode *M) {
|
||||||
pImpl->erase(M);
|
pImpl->erase(M);
|
||||||
}
|
}
|
||||||
|
|
||||||
void LLVMContext::erase(ConstantAggregateZero *Z) {
|
|
||||||
pImpl->erase(Z);
|
|
||||||
}
|
|
||||||
|
@ -19,8 +19,6 @@
|
|||||||
#include "llvm/Metadata.h"
|
#include "llvm/Metadata.h"
|
||||||
using namespace llvm;
|
using namespace llvm;
|
||||||
|
|
||||||
static char getValType(ConstantAggregateZero *CPZ) { return 0; }
|
|
||||||
|
|
||||||
LLVMContextImpl::LLVMContextImpl(LLVMContext &C) :
|
LLVMContextImpl::LLVMContextImpl(LLVMContext &C) :
|
||||||
Context(C), TheTrueVal(0), TheFalseVal(0) { }
|
Context(C), TheTrueVal(0), TheFalseVal(0) { }
|
||||||
|
|
||||||
@ -59,15 +57,6 @@ MDNode *LLVMContextImpl::getMDNode(Value*const* Vals, unsigned NumVals) {
|
|||||||
return N;
|
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 ***
|
// *** erase methods ***
|
||||||
|
|
||||||
void LLVMContextImpl::erase(MDString *M) {
|
void LLVMContextImpl::erase(MDString *M) {
|
||||||
@ -79,7 +68,3 @@ void LLVMContextImpl::erase(MDNode *M) {
|
|||||||
sys::SmartScopedWriter<true> Writer(ConstantsLock);
|
sys::SmartScopedWriter<true> Writer(ConstantsLock);
|
||||||
MDNodeSet.RemoveNode(M);
|
MDNodeSet.RemoveNode(M);
|
||||||
}
|
}
|
||||||
|
|
||||||
void LLVMContextImpl::erase(ConstantAggregateZero *Z) {
|
|
||||||
AggZeroConstants.remove(Z);
|
|
||||||
}
|
|
||||||
|
@ -74,7 +74,7 @@ template<>
|
|||||||
struct ConvertConstantType<ConstantAggregateZero, Type> {
|
struct ConvertConstantType<ConstantAggregateZero, Type> {
|
||||||
static void convert(ConstantAggregateZero *OldC, const Type *NewTy) {
|
static void convert(ConstantAggregateZero *OldC, const Type *NewTy) {
|
||||||
// Make everyone now use a constant of the new type...
|
// 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??");
|
assert(New != OldC && "Didn't replace constant??");
|
||||||
OldC->uncheckedReplaceAllUsesWith(New);
|
OldC->uncheckedReplaceAllUsesWith(New);
|
||||||
OldC->destroyConstant(); // This constant is now dead, destroy it.
|
OldC->destroyConstant(); // This constant is now dead, destroy it.
|
||||||
@ -461,6 +461,7 @@ class LLVMContextImpl {
|
|||||||
friend class ConstantStruct;
|
friend class ConstantStruct;
|
||||||
friend class ConstantArray;
|
friend class ConstantArray;
|
||||||
friend class ConstantVector;
|
friend class ConstantVector;
|
||||||
|
friend class ConstantAggregateZero;
|
||||||
public:
|
public:
|
||||||
LLVMContextImpl(LLVMContext &C);
|
LLVMContextImpl(LLVMContext &C);
|
||||||
|
|
||||||
@ -468,8 +469,6 @@ public:
|
|||||||
|
|
||||||
MDNode *getMDNode(Value*const* Vals, unsigned NumVals);
|
MDNode *getMDNode(Value*const* Vals, unsigned NumVals);
|
||||||
|
|
||||||
ConstantAggregateZero *getConstantAggregateZero(const Type *Ty);
|
|
||||||
|
|
||||||
ConstantInt *getTrue() {
|
ConstantInt *getTrue() {
|
||||||
if (TheTrueVal)
|
if (TheTrueVal)
|
||||||
return TheTrueVal;
|
return TheTrueVal;
|
||||||
@ -486,7 +485,6 @@ public:
|
|||||||
|
|
||||||
void erase(MDString *M);
|
void erase(MDString *M);
|
||||||
void erase(MDNode *M);
|
void erase(MDNode *M);
|
||||||
void erase(ConstantAggregateZero *Z);
|
|
||||||
};
|
};
|
||||||
|
|
||||||
}
|
}
|
||||||
|
@ -72,7 +72,7 @@ Module *BugDriver::deleteInstructionFromProgram(const Instruction *I,
|
|||||||
|
|
||||||
// If this instruction produces a value, replace any users with null values
|
// If this instruction produces a value, replace any users with null values
|
||||||
if (isa<StructType>(TheInst->getType()))
|
if (isa<StructType>(TheInst->getType()))
|
||||||
TheInst->replaceAllUsesWith(Context.getUndef(TheInst->getType()));
|
TheInst->replaceAllUsesWith(UndefValue::get(TheInst->getType()));
|
||||||
else if (TheInst->getType() != Type::VoidTy)
|
else if (TheInst->getType() != Type::VoidTy)
|
||||||
TheInst->replaceAllUsesWith(Context.getNullValue(TheInst->getType()));
|
TheInst->replaceAllUsesWith(Context.getNullValue(TheInst->getType()));
|
||||||
|
|
||||||
|
@ -733,7 +733,7 @@ static void CleanupAndPrepareModules(BugDriver &BD, Module *&Test,
|
|||||||
// function that dynamically resolves the calls to F via our JIT API
|
// function that dynamically resolves the calls to F via our JIT API
|
||||||
if (!F->use_empty()) {
|
if (!F->use_empty()) {
|
||||||
// Create a new global to hold the cached function pointer.
|
// Create a new global to hold the cached function pointer.
|
||||||
Constant *NullPtr = Context.getConstantPointerNull(F->getType());
|
Constant *NullPtr = ConstantPointerNull::get(F->getType());
|
||||||
GlobalVariable *Cache =
|
GlobalVariable *Cache =
|
||||||
new GlobalVariable(*F->getParent(), F->getType(),
|
new GlobalVariable(*F->getParent(), F->getType(),
|
||||||
false, GlobalValue::InternalLinkage,
|
false, GlobalValue::InternalLinkage,
|
||||||
|
@ -21,7 +21,7 @@ TEST(ConstantsTest, Integer_i1) {
|
|||||||
Constant* Zero = ConstantInt::get(Int1, 0);
|
Constant* Zero = ConstantInt::get(Int1, 0);
|
||||||
Constant* NegOne = ConstantInt::get(Int1, static_cast<uint64_t>(-1), true);
|
Constant* NegOne = ConstantInt::get(Int1, static_cast<uint64_t>(-1), true);
|
||||||
EXPECT_EQ(NegOne, ConstantInt::getSigned(Int1, -1));
|
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)
|
// Input: @b = constant i1 add(i1 1 , i1 1)
|
||||||
// Output: @b = constant i1 false
|
// Output: @b = constant i1 false
|
||||||
|
Loading…
Reference in New Issue
Block a user