mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2025-01-18 01:35:44 +00:00
Value* were never meant to be const. Removing constness from the constant
folder removes a lot of const_casting and requires no changes to clang or llvm-gcc. llvm-svn: 82349
This commit is contained in:
Nick Lewycky
parent
5b5a0ec095
commit
ca1f29ee1b
@ -73,7 +73,7 @@ static Constant *BitCastConstantVector(LLVMContext &Context, ConstantVector *CV,
|
||||
static unsigned
|
||||
foldConstantCastPair(
|
||||
unsigned opc, ///< opcode of the second cast constant expression
|
||||
const ConstantExpr*Op, ///< the first cast constant expression
|
||||
ConstantExpr *Op, ///< the first cast constant expression
|
||||
const Type *DstTy ///< desintation type of the first cast
|
||||
) {
|
||||
assert(Op && Op->isCast() && "Can't fold cast of cast without a cast!");
|
||||
@ -156,7 +156,7 @@ static Constant *FoldBitCast(LLVMContext &Context,
|
||||
return ConstantPointerNull::get(cast<PointerType>(DestTy));
|
||||
|
||||
// Handle integral constant input.
|
||||
if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
|
||||
if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
|
||||
if (DestTy->isInteger())
|
||||
// Integral -> Integral. This is a no-op because the bit widths must
|
||||
// be the same. Consequently, we just fold to V.
|
||||
@ -171,7 +171,7 @@ static Constant *FoldBitCast(LLVMContext &Context,
|
||||
}
|
||||
|
||||
// Handle ConstantFP input.
|
||||
if (const ConstantFP *FP = dyn_cast<ConstantFP>(V))
|
||||
if (ConstantFP *FP = dyn_cast<ConstantFP>(V))
|
||||
// FP -> Integral.
|
||||
return ConstantInt::get(Context, FP->getValueAPF().bitcastToAPInt());
|
||||
|
||||
@ -180,7 +180,7 @@ static Constant *FoldBitCast(LLVMContext &Context,
|
||||
|
||||
|
||||
Constant *llvm::ConstantFoldCastInstruction(LLVMContext &Context,
|
||||
unsigned opc, const Constant *V,
|
||||
unsigned opc, Constant *V,
|
||||
const Type *DestTy) {
|
||||
if (isa<UndefValue>(V)) {
|
||||
// zext(undef) = 0, because the top bits will be zero.
|
||||
@ -197,7 +197,7 @@ Constant *llvm::ConstantFoldCastInstruction(LLVMContext &Context,
|
||||
|
||||
// If the cast operand is a constant expression, there's a few things we can
|
||||
// do to try to simplify it.
|
||||
if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) {
|
||||
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) {
|
||||
if (CE->isCast()) {
|
||||
// Try hard to fold cast of cast because they are often eliminable.
|
||||
if (unsigned newOpc = foldConstantCastPair(opc, CE, DestTy))
|
||||
@ -220,7 +220,7 @@ Constant *llvm::ConstantFoldCastInstruction(LLVMContext &Context,
|
||||
// If the cast operand is a constant vector, perform the cast by
|
||||
// operating on each element. In the cast of bitcasts, the element
|
||||
// count may be mismatched; don't attempt to handle that here.
|
||||
if (const ConstantVector *CV = dyn_cast<ConstantVector>(V))
|
||||
if (ConstantVector *CV = dyn_cast<ConstantVector>(V))
|
||||
if (isa<VectorType>(DestTy) &&
|
||||
cast<VectorType>(DestTy)->getNumElements() ==
|
||||
CV->getType()->getNumElements()) {
|
||||
@ -238,7 +238,7 @@ Constant *llvm::ConstantFoldCastInstruction(LLVMContext &Context,
|
||||
switch (opc) {
|
||||
case Instruction::FPTrunc:
|
||||
case Instruction::FPExt:
|
||||
if (const ConstantFP *FPC = dyn_cast<ConstantFP>(V)) {
|
||||
if (ConstantFP *FPC = dyn_cast<ConstantFP>(V)) {
|
||||
bool ignored;
|
||||
APFloat Val = FPC->getValueAPF();
|
||||
Val.convert(DestTy == Type::getFloatTy(Context) ? APFloat::IEEEsingle :
|
||||
@ -252,7 +252,7 @@ Constant *llvm::ConstantFoldCastInstruction(LLVMContext &Context,
|
||||
return 0; // Can't fold.
|
||||
case Instruction::FPToUI:
|
||||
case Instruction::FPToSI:
|
||||
if (const ConstantFP *FPC = dyn_cast<ConstantFP>(V)) {
|
||||
if (ConstantFP *FPC = dyn_cast<ConstantFP>(V)) {
|
||||
const APFloat &V = FPC->getValueAPF();
|
||||
bool ignored;
|
||||
uint64_t x[2];
|
||||
@ -273,7 +273,7 @@ Constant *llvm::ConstantFoldCastInstruction(LLVMContext &Context,
|
||||
return 0; // Other pointer types cannot be casted
|
||||
case Instruction::UIToFP:
|
||||
case Instruction::SIToFP:
|
||||
if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
|
||||
if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
|
||||
APInt api = CI->getValue();
|
||||
const uint64_t zero[] = {0, 0};
|
||||
APFloat apf = APFloat(APInt(DestTy->getPrimitiveSizeInBits(),
|
||||
@ -285,7 +285,7 @@ Constant *llvm::ConstantFoldCastInstruction(LLVMContext &Context,
|
||||
}
|
||||
return 0;
|
||||
case Instruction::ZExt:
|
||||
if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
|
||||
if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
|
||||
uint32_t BitWidth = cast<IntegerType>(DestTy)->getBitWidth();
|
||||
APInt Result(CI->getValue());
|
||||
Result.zext(BitWidth);
|
||||
@ -293,7 +293,7 @@ Constant *llvm::ConstantFoldCastInstruction(LLVMContext &Context,
|
||||
}
|
||||
return 0;
|
||||
case Instruction::SExt:
|
||||
if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
|
||||
if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
|
||||
uint32_t BitWidth = cast<IntegerType>(DestTy)->getBitWidth();
|
||||
APInt Result(CI->getValue());
|
||||
Result.sext(BitWidth);
|
||||
@ -301,7 +301,7 @@ Constant *llvm::ConstantFoldCastInstruction(LLVMContext &Context,
|
||||
}
|
||||
return 0;
|
||||
case Instruction::Trunc:
|
||||
if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
|
||||
if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
|
||||
uint32_t BitWidth = cast<IntegerType>(DestTy)->getBitWidth();
|
||||
APInt Result(CI->getValue());
|
||||
Result.trunc(BitWidth);
|
||||
@ -309,7 +309,7 @@ Constant *llvm::ConstantFoldCastInstruction(LLVMContext &Context,
|
||||
}
|
||||
return 0;
|
||||
case Instruction::BitCast:
|
||||
return FoldBitCast(Context, const_cast<Constant*>(V), DestTy);
|
||||
return FoldBitCast(Context, V, DestTy);
|
||||
default:
|
||||
assert(!"Invalid CE CastInst opcode");
|
||||
break;
|
||||
@ -320,30 +320,29 @@ Constant *llvm::ConstantFoldCastInstruction(LLVMContext &Context,
|
||||
}
|
||||
|
||||
Constant *llvm::ConstantFoldSelectInstruction(LLVMContext&,
|
||||
const Constant *Cond,
|
||||
const Constant *V1,
|
||||
const Constant *V2) {
|
||||
if (const ConstantInt *CB = dyn_cast<ConstantInt>(Cond))
|
||||
return const_cast<Constant*>(CB->getZExtValue() ? V1 : V2);
|
||||
Constant *Cond,
|
||||
Constant *V1, Constant *V2) {
|
||||
if (ConstantInt *CB = dyn_cast<ConstantInt>(Cond))
|
||||
return CB->getZExtValue() ? V1 : V2;
|
||||
|
||||
if (isa<UndefValue>(V1)) return const_cast<Constant*>(V2);
|
||||
if (isa<UndefValue>(V2)) return const_cast<Constant*>(V1);
|
||||
if (isa<UndefValue>(Cond)) return const_cast<Constant*>(V1);
|
||||
if (V1 == V2) return const_cast<Constant*>(V1);
|
||||
if (isa<UndefValue>(V1)) return V2;
|
||||
if (isa<UndefValue>(V2)) return V1;
|
||||
if (isa<UndefValue>(Cond)) return V1;
|
||||
if (V1 == V2) return V1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
Constant *llvm::ConstantFoldExtractElementInstruction(LLVMContext &Context,
|
||||
const Constant *Val,
|
||||
const Constant *Idx) {
|
||||
Constant *Val,
|
||||
Constant *Idx) {
|
||||
if (isa<UndefValue>(Val)) // ee(undef, x) -> undef
|
||||
return UndefValue::get(cast<VectorType>(Val->getType())->getElementType());
|
||||
if (Val->isNullValue()) // ee(zero, x) -> zero
|
||||
return Constant::getNullValue(
|
||||
cast<VectorType>(Val->getType())->getElementType());
|
||||
|
||||
if (const ConstantVector *CVal = dyn_cast<ConstantVector>(Val)) {
|
||||
if (const ConstantInt *CIdx = dyn_cast<ConstantInt>(Idx)) {
|
||||
if (ConstantVector *CVal = dyn_cast<ConstantVector>(Val)) {
|
||||
if (ConstantInt *CIdx = dyn_cast<ConstantInt>(Idx)) {
|
||||
return CVal->getOperand(CIdx->getZExtValue());
|
||||
} else if (isa<UndefValue>(Idx)) {
|
||||
// ee({w,x,y,z}, undef) -> w (an arbitrary value).
|
||||
@ -354,17 +353,17 @@ Constant *llvm::ConstantFoldExtractElementInstruction(LLVMContext &Context,
|
||||
}
|
||||
|
||||
Constant *llvm::ConstantFoldInsertElementInstruction(LLVMContext &Context,
|
||||
const Constant *Val,
|
||||
const Constant *Elt,
|
||||
const Constant *Idx) {
|
||||
const ConstantInt *CIdx = dyn_cast<ConstantInt>(Idx);
|
||||
Constant *Val,
|
||||
Constant *Elt,
|
||||
Constant *Idx) {
|
||||
ConstantInt *CIdx = dyn_cast<ConstantInt>(Idx);
|
||||
if (!CIdx) return 0;
|
||||
APInt idxVal = CIdx->getValue();
|
||||
if (isa<UndefValue>(Val)) {
|
||||
// Insertion of scalar constant into vector undef
|
||||
// Optimize away insertion of undef
|
||||
if (isa<UndefValue>(Elt))
|
||||
return const_cast<Constant*>(Val);
|
||||
return Val;
|
||||
// Otherwise break the aggregate undef into multiple undefs and do
|
||||
// the insertion
|
||||
unsigned numOps =
|
||||
@ -372,9 +371,9 @@ Constant *llvm::ConstantFoldInsertElementInstruction(LLVMContext &Context,
|
||||
std::vector<Constant*> Ops;
|
||||
Ops.reserve(numOps);
|
||||
for (unsigned i = 0; i < numOps; ++i) {
|
||||
const Constant *Op =
|
||||
Constant *Op =
|
||||
(idxVal == i) ? Elt : UndefValue::get(Elt->getType());
|
||||
Ops.push_back(const_cast<Constant*>(Op));
|
||||
Ops.push_back(Op);
|
||||
}
|
||||
return ConstantVector::get(Ops);
|
||||
}
|
||||
@ -382,7 +381,7 @@ Constant *llvm::ConstantFoldInsertElementInstruction(LLVMContext &Context,
|
||||
// Insertion of scalar constant into vector aggregate zero
|
||||
// Optimize away insertion of zero
|
||||
if (Elt->isNullValue())
|
||||
return const_cast<Constant*>(Val);
|
||||
return Val;
|
||||
// Otherwise break the aggregate zero into multiple zeros and do
|
||||
// the insertion
|
||||
unsigned numOps =
|
||||
@ -390,20 +389,20 @@ Constant *llvm::ConstantFoldInsertElementInstruction(LLVMContext &Context,
|
||||
std::vector<Constant*> Ops;
|
||||
Ops.reserve(numOps);
|
||||
for (unsigned i = 0; i < numOps; ++i) {
|
||||
const Constant *Op =
|
||||
Constant *Op =
|
||||
(idxVal == i) ? Elt : Constant::getNullValue(Elt->getType());
|
||||
Ops.push_back(const_cast<Constant*>(Op));
|
||||
Ops.push_back(Op);
|
||||
}
|
||||
return ConstantVector::get(Ops);
|
||||
}
|
||||
if (const ConstantVector *CVal = dyn_cast<ConstantVector>(Val)) {
|
||||
if (ConstantVector *CVal = dyn_cast<ConstantVector>(Val)) {
|
||||
// Insertion of scalar constant into vector constant
|
||||
std::vector<Constant*> Ops;
|
||||
Ops.reserve(CVal->getNumOperands());
|
||||
for (unsigned i = 0; i < CVal->getNumOperands(); ++i) {
|
||||
const Constant *Op =
|
||||
Constant *Op =
|
||||
(idxVal == i) ? Elt : cast<Constant>(CVal->getOperand(i));
|
||||
Ops.push_back(const_cast<Constant*>(Op));
|
||||
Ops.push_back(Op);
|
||||
}
|
||||
return ConstantVector::get(Ops);
|
||||
}
|
||||
@ -413,9 +412,9 @@ Constant *llvm::ConstantFoldInsertElementInstruction(LLVMContext &Context,
|
||||
|
||||
/// GetVectorElement - If C is a ConstantVector, ConstantAggregateZero or Undef
|
||||
/// return the specified element value. Otherwise return null.
|
||||
static Constant *GetVectorElement(LLVMContext &Context, const Constant *C,
|
||||
static Constant *GetVectorElement(LLVMContext &Context, Constant *C,
|
||||
unsigned EltNo) {
|
||||
if (const ConstantVector *CV = dyn_cast<ConstantVector>(C))
|
||||
if (ConstantVector *CV = dyn_cast<ConstantVector>(C))
|
||||
return CV->getOperand(EltNo);
|
||||
|
||||
const Type *EltTy = cast<VectorType>(C->getType())->getElementType();
|
||||
@ -427,9 +426,9 @@ static Constant *GetVectorElement(LLVMContext &Context, const Constant *C,
|
||||
}
|
||||
|
||||
Constant *llvm::ConstantFoldShuffleVectorInstruction(LLVMContext &Context,
|
||||
const Constant *V1,
|
||||
const Constant *V2,
|
||||
const Constant *Mask) {
|
||||
Constant *V1,
|
||||
Constant *V2,
|
||||
Constant *Mask) {
|
||||
// Undefined shuffle mask -> undefined value.
|
||||
if (isa<UndefValue>(Mask)) return UndefValue::get(V1->getType());
|
||||
|
||||
@ -465,12 +464,12 @@ Constant *llvm::ConstantFoldShuffleVectorInstruction(LLVMContext &Context,
|
||||
}
|
||||
|
||||
Constant *llvm::ConstantFoldExtractValueInstruction(LLVMContext &Context,
|
||||
const Constant *Agg,
|
||||
Constant *Agg,
|
||||
const unsigned *Idxs,
|
||||
unsigned NumIdx) {
|
||||
// Base case: no indices, so return the entire value.
|
||||
if (NumIdx == 0)
|
||||
return const_cast<Constant *>(Agg);
|
||||
return Agg;
|
||||
|
||||
if (isa<UndefValue>(Agg)) // ev(undef, x) -> undef
|
||||
return UndefValue::get(ExtractValueInst::getIndexedType(Agg->getType(),
|
||||
@ -489,19 +488,19 @@ Constant *llvm::ConstantFoldExtractValueInstruction(LLVMContext &Context,
|
||||
}
|
||||
|
||||
Constant *llvm::ConstantFoldInsertValueInstruction(LLVMContext &Context,
|
||||
const Constant *Agg,
|
||||
const Constant *Val,
|
||||
Constant *Agg,
|
||||
Constant *Val,
|
||||
const unsigned *Idxs,
|
||||
unsigned NumIdx) {
|
||||
// Base case: no indices, so replace the entire value.
|
||||
if (NumIdx == 0)
|
||||
return const_cast<Constant *>(Val);
|
||||
return Val;
|
||||
|
||||
if (isa<UndefValue>(Agg)) {
|
||||
// Insertion of constant into aggregate undef
|
||||
// Optimize away insertion of undef.
|
||||
if (isa<UndefValue>(Val))
|
||||
return const_cast<Constant*>(Agg);
|
||||
return Agg;
|
||||
|
||||
// Otherwise break the aggregate undef into multiple undefs and do
|
||||
// the insertion.
|
||||
@ -515,12 +514,12 @@ Constant *llvm::ConstantFoldInsertValueInstruction(LLVMContext &Context,
|
||||
std::vector<Constant*> Ops(numOps);
|
||||
for (unsigned i = 0; i < numOps; ++i) {
|
||||
const Type *MemberTy = AggTy->getTypeAtIndex(i);
|
||||
const Constant *Op =
|
||||
Constant *Op =
|
||||
(*Idxs == i) ?
|
||||
ConstantFoldInsertValueInstruction(Context, UndefValue::get(MemberTy),
|
||||
Val, Idxs+1, NumIdx-1) :
|
||||
UndefValue::get(MemberTy);
|
||||
Ops[i] = const_cast<Constant*>(Op);
|
||||
Ops[i] = Op;
|
||||
}
|
||||
|
||||
if (const StructType* ST = dyn_cast<StructType>(AggTy))
|
||||
@ -532,7 +531,7 @@ Constant *llvm::ConstantFoldInsertValueInstruction(LLVMContext &Context,
|
||||
// Insertion of constant into aggregate zero
|
||||
// Optimize away insertion of zero.
|
||||
if (Val->isNullValue())
|
||||
return const_cast<Constant*>(Agg);
|
||||
return Agg;
|
||||
|
||||
// Otherwise break the aggregate zero into multiple zeros and do
|
||||
// the insertion.
|
||||
@ -546,13 +545,13 @@ Constant *llvm::ConstantFoldInsertValueInstruction(LLVMContext &Context,
|
||||
std::vector<Constant*> Ops(numOps);
|
||||
for (unsigned i = 0; i < numOps; ++i) {
|
||||
const Type *MemberTy = AggTy->getTypeAtIndex(i);
|
||||
const Constant *Op =
|
||||
Constant *Op =
|
||||
(*Idxs == i) ?
|
||||
ConstantFoldInsertValueInstruction(Context,
|
||||
Constant::getNullValue(MemberTy),
|
||||
Val, Idxs+1, NumIdx-1) :
|
||||
Constant::getNullValue(MemberTy);
|
||||
Ops[i] = const_cast<Constant*>(Op);
|
||||
Ops[i] = Op;
|
||||
}
|
||||
|
||||
if (const StructType* ST = dyn_cast<StructType>(AggTy))
|
||||
@ -564,12 +563,12 @@ Constant *llvm::ConstantFoldInsertValueInstruction(LLVMContext &Context,
|
||||
// Insertion of constant into aggregate constant.
|
||||
std::vector<Constant*> Ops(Agg->getNumOperands());
|
||||
for (unsigned i = 0; i < Agg->getNumOperands(); ++i) {
|
||||
const Constant *Op =
|
||||
Constant *Op =
|
||||
(*Idxs == i) ?
|
||||
ConstantFoldInsertValueInstruction(Context, Agg->getOperand(i),
|
||||
Val, Idxs+1, NumIdx-1) :
|
||||
Agg->getOperand(i);
|
||||
Ops[i] = const_cast<Constant*>(Op);
|
||||
Ops[i] = Op;
|
||||
}
|
||||
|
||||
if (const StructType* ST = dyn_cast<StructType>(Agg->getType()))
|
||||
@ -583,8 +582,7 @@ Constant *llvm::ConstantFoldInsertValueInstruction(LLVMContext &Context,
|
||||
|
||||
Constant *llvm::ConstantFoldBinaryInstruction(LLVMContext &Context,
|
||||
unsigned Opcode,
|
||||
const Constant *C1,
|
||||
const Constant *C2) {
|
||||
Constant *C1, Constant *C2) {
|
||||
// No compile-time operations on this type yet.
|
||||
if (C1->getType() == Type::getPPC_FP128Ty(Context))
|
||||
return 0;
|
||||
@ -610,23 +608,23 @@ Constant *llvm::ConstantFoldBinaryInstruction(LLVMContext &Context,
|
||||
case Instruction::SRem:
|
||||
if (!isa<UndefValue>(C2)) // undef / X -> 0
|
||||
return Constant::getNullValue(C1->getType());
|
||||
return const_cast<Constant*>(C2); // X / undef -> undef
|
||||
return C2; // X / undef -> undef
|
||||
case Instruction::Or: // X | undef -> -1
|
||||
if (const VectorType *PTy = dyn_cast<VectorType>(C1->getType()))
|
||||
return Constant::getAllOnesValue(PTy);
|
||||
return Constant::getAllOnesValue(C1->getType());
|
||||
case Instruction::LShr:
|
||||
if (isa<UndefValue>(C2) && isa<UndefValue>(C1))
|
||||
return const_cast<Constant*>(C1); // undef lshr undef -> undef
|
||||
return C1; // undef lshr undef -> undef
|
||||
return Constant::getNullValue(C1->getType()); // X lshr undef -> 0
|
||||
// undef lshr X -> 0
|
||||
case Instruction::AShr:
|
||||
if (!isa<UndefValue>(C2))
|
||||
return const_cast<Constant*>(C1); // undef ashr X --> undef
|
||||
return C1; // undef ashr X --> undef
|
||||
else if (isa<UndefValue>(C1))
|
||||
return const_cast<Constant*>(C1); // undef ashr undef -> undef
|
||||
return C1; // undef ashr undef -> undef
|
||||
else
|
||||
return const_cast<Constant*>(C1); // X ashr undef --> X
|
||||
return C1; // X ashr undef --> X
|
||||
case Instruction::Shl:
|
||||
// undef << X -> 0 or X << undef -> 0
|
||||
return Constant::getNullValue(C1->getType());
|
||||
@ -634,23 +632,23 @@ Constant *llvm::ConstantFoldBinaryInstruction(LLVMContext &Context,
|
||||
}
|
||||
|
||||
// Handle simplifications when the RHS is a constant int.
|
||||
if (const ConstantInt *CI2 = dyn_cast<ConstantInt>(C2)) {
|
||||
if (ConstantInt *CI2 = dyn_cast<ConstantInt>(C2)) {
|
||||
switch (Opcode) {
|
||||
case Instruction::Add:
|
||||
if (CI2->equalsInt(0)) return const_cast<Constant*>(C1); // X + 0 == X
|
||||
if (CI2->equalsInt(0)) return C1; // X + 0 == X
|
||||
break;
|
||||
case Instruction::Sub:
|
||||
if (CI2->equalsInt(0)) return const_cast<Constant*>(C1); // X - 0 == X
|
||||
if (CI2->equalsInt(0)) return C1; // X - 0 == X
|
||||
break;
|
||||
case Instruction::Mul:
|
||||
if (CI2->equalsInt(0)) return const_cast<Constant*>(C2); // X * 0 == 0
|
||||
if (CI2->equalsInt(0)) return C2; // X * 0 == 0
|
||||
if (CI2->equalsInt(1))
|
||||
return const_cast<Constant*>(C1); // X * 1 == X
|
||||
return C1; // X * 1 == X
|
||||
break;
|
||||
case Instruction::UDiv:
|
||||
case Instruction::SDiv:
|
||||
if (CI2->equalsInt(1))
|
||||
return const_cast<Constant*>(C1); // X / 1 == X
|
||||
return C1; // X / 1 == X
|
||||
if (CI2->equalsInt(0))
|
||||
return UndefValue::get(CI2->getType()); // X / 0 == undef
|
||||
break;
|
||||
@ -662,11 +660,11 @@ Constant *llvm::ConstantFoldBinaryInstruction(LLVMContext &Context,
|
||||
return UndefValue::get(CI2->getType()); // X % 0 == undef
|
||||
break;
|
||||
case Instruction::And:
|
||||
if (CI2->isZero()) return const_cast<Constant*>(C2); // X & 0 == 0
|
||||
if (CI2->isZero()) return C2; // X & 0 == 0
|
||||
if (CI2->isAllOnesValue())
|
||||
return const_cast<Constant*>(C1); // X & -1 == X
|
||||
return C1; // X & -1 == X
|
||||
|
||||
if (const ConstantExpr *CE1 = dyn_cast<ConstantExpr>(C1)) {
|
||||
if (ConstantExpr *CE1 = dyn_cast<ConstantExpr>(C1)) {
|
||||
// (zext i32 to i64) & 4294967295 -> (zext i32 to i64)
|
||||
if (CE1->getOpcode() == Instruction::ZExt) {
|
||||
unsigned DstWidth = CI2->getType()->getBitWidth();
|
||||
@ -674,7 +672,7 @@ Constant *llvm::ConstantFoldBinaryInstruction(LLVMContext &Context,
|
||||
CE1->getOperand(0)->getType()->getPrimitiveSizeInBits();
|
||||
APInt PossiblySetBits(APInt::getLowBitsSet(DstWidth, SrcWidth));
|
||||
if ((PossiblySetBits & CI2->getValue()) == PossiblySetBits)
|
||||
return const_cast<Constant*>(C1);
|
||||
return C1;
|
||||
}
|
||||
|
||||
// If and'ing the address of a global with a constant, fold it.
|
||||
@ -700,26 +698,25 @@ Constant *llvm::ConstantFoldBinaryInstruction(LLVMContext &Context,
|
||||
}
|
||||
break;
|
||||
case Instruction::Or:
|
||||
if (CI2->equalsInt(0)) return const_cast<Constant*>(C1); // X | 0 == X
|
||||
if (CI2->equalsInt(0)) return C1; // X | 0 == X
|
||||
if (CI2->isAllOnesValue())
|
||||
return const_cast<Constant*>(C2); // X | -1 == -1
|
||||
return C2; // X | -1 == -1
|
||||
break;
|
||||
case Instruction::Xor:
|
||||
if (CI2->equalsInt(0)) return const_cast<Constant*>(C1); // X ^ 0 == X
|
||||
if (CI2->equalsInt(0)) return C1; // X ^ 0 == X
|
||||
break;
|
||||
case Instruction::AShr:
|
||||
// ashr (zext C to Ty), C2 -> lshr (zext C, CSA), C2
|
||||
if (const ConstantExpr *CE1 = dyn_cast<ConstantExpr>(C1))
|
||||
if (ConstantExpr *CE1 = dyn_cast<ConstantExpr>(C1))
|
||||
if (CE1->getOpcode() == Instruction::ZExt) // Top bits known zero.
|
||||
return ConstantExpr::getLShr(const_cast<Constant*>(C1),
|
||||
const_cast<Constant*>(C2));
|
||||
return ConstantExpr::getLShr(C1, C2);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// At this point we know neither constant is an UndefValue.
|
||||
if (const ConstantInt *CI1 = dyn_cast<ConstantInt>(C1)) {
|
||||
if (const ConstantInt *CI2 = dyn_cast<ConstantInt>(C2)) {
|
||||
if (ConstantInt *CI1 = dyn_cast<ConstantInt>(C1)) {
|
||||
if (ConstantInt *CI2 = dyn_cast<ConstantInt>(C2)) {
|
||||
using namespace APIntOps;
|
||||
const APInt &C1V = CI1->getValue();
|
||||
const APInt &C2V = CI2->getValue();
|
||||
@ -786,13 +783,13 @@ Constant *llvm::ConstantFoldBinaryInstruction(LLVMContext &Context,
|
||||
case Instruction::LShr:
|
||||
case Instruction::AShr:
|
||||
case Instruction::Shl:
|
||||
if (CI1->equalsInt(0)) return const_cast<Constant*>(C1);
|
||||
if (CI1->equalsInt(0)) return C1;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
} else if (const ConstantFP *CFP1 = dyn_cast<ConstantFP>(C1)) {
|
||||
if (const ConstantFP *CFP2 = dyn_cast<ConstantFP>(C2)) {
|
||||
} else if (ConstantFP *CFP1 = dyn_cast<ConstantFP>(C1)) {
|
||||
if (ConstantFP *CFP2 = dyn_cast<ConstantFP>(C2)) {
|
||||
APFloat C1V = CFP1->getValueAPF();
|
||||
APFloat C2V = CFP2->getValueAPF();
|
||||
APFloat C3V = C1V; // copy for modification
|
||||
@ -817,14 +814,14 @@ Constant *llvm::ConstantFoldBinaryInstruction(LLVMContext &Context,
|
||||
}
|
||||
}
|
||||
} else if (const VectorType *VTy = dyn_cast<VectorType>(C1->getType())) {
|
||||
const ConstantVector *CP1 = dyn_cast<ConstantVector>(C1);
|
||||
const ConstantVector *CP2 = dyn_cast<ConstantVector>(C2);
|
||||
ConstantVector *CP1 = dyn_cast<ConstantVector>(C1);
|
||||
ConstantVector *CP2 = dyn_cast<ConstantVector>(C2);
|
||||
if ((CP1 != NULL || isa<ConstantAggregateZero>(C1)) &&
|
||||
(CP2 != NULL || isa<ConstantAggregateZero>(C2))) {
|
||||
std::vector<Constant*> Res;
|
||||
const Type* EltTy = VTy->getElementType();
|
||||
const Constant *C1 = 0;
|
||||
const Constant *C2 = 0;
|
||||
Constant *C1 = 0;
|
||||
Constant *C2 = 0;
|
||||
switch (Opcode) {
|
||||
default:
|
||||
break;
|
||||
@ -832,144 +829,126 @@ Constant *llvm::ConstantFoldBinaryInstruction(LLVMContext &Context,
|
||||
for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
|
||||
C1 = CP1 ? CP1->getOperand(i) : Constant::getNullValue(EltTy);
|
||||
C2 = CP2 ? CP2->getOperand(i) : Constant::getNullValue(EltTy);
|
||||
Res.push_back(ConstantExpr::getAdd(const_cast<Constant*>(C1),
|
||||
const_cast<Constant*>(C2)));
|
||||
Res.push_back(ConstantExpr::getAdd(C1, C2));
|
||||
}
|
||||
return ConstantVector::get(Res);
|
||||
case Instruction::FAdd:
|
||||
for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
|
||||
C1 = CP1 ? CP1->getOperand(i) : Constant::getNullValue(EltTy);
|
||||
C2 = CP2 ? CP2->getOperand(i) : Constant::getNullValue(EltTy);
|
||||
Res.push_back(ConstantExpr::getFAdd(const_cast<Constant*>(C1),
|
||||
const_cast<Constant*>(C2)));
|
||||
Res.push_back(ConstantExpr::getFAdd(C1, C2));
|
||||
}
|
||||
return ConstantVector::get(Res);
|
||||
case Instruction::Sub:
|
||||
for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
|
||||
C1 = CP1 ? CP1->getOperand(i) : Constant::getNullValue(EltTy);
|
||||
C2 = CP2 ? CP2->getOperand(i) : Constant::getNullValue(EltTy);
|
||||
Res.push_back(ConstantExpr::getSub(const_cast<Constant*>(C1),
|
||||
const_cast<Constant*>(C2)));
|
||||
Res.push_back(ConstantExpr::getSub(C1, C2));
|
||||
}
|
||||
return ConstantVector::get(Res);
|
||||
case Instruction::FSub:
|
||||
for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
|
||||
C1 = CP1 ? CP1->getOperand(i) : Constant::getNullValue(EltTy);
|
||||
C2 = CP2 ? CP2->getOperand(i) : Constant::getNullValue(EltTy);
|
||||
Res.push_back(ConstantExpr::getFSub(const_cast<Constant*>(C1),
|
||||
const_cast<Constant*>(C2)));
|
||||
Res.push_back(ConstantExpr::getFSub(C1, C2));
|
||||
}
|
||||
return ConstantVector::get(Res);
|
||||
case Instruction::Mul:
|
||||
for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
|
||||
C1 = CP1 ? CP1->getOperand(i) : Constant::getNullValue(EltTy);
|
||||
C2 = CP2 ? CP2->getOperand(i) : Constant::getNullValue(EltTy);
|
||||
Res.push_back(ConstantExpr::getMul(const_cast<Constant*>(C1),
|
||||
const_cast<Constant*>(C2)));
|
||||
Res.push_back(ConstantExpr::getMul(C1, C2));
|
||||
}
|
||||
return ConstantVector::get(Res);
|
||||
case Instruction::FMul:
|
||||
for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
|
||||
C1 = CP1 ? CP1->getOperand(i) : Constant::getNullValue(EltTy);
|
||||
C2 = CP2 ? CP2->getOperand(i) : Constant::getNullValue(EltTy);
|
||||
Res.push_back(ConstantExpr::getFMul(const_cast<Constant*>(C1),
|
||||
const_cast<Constant*>(C2)));
|
||||
Res.push_back(ConstantExpr::getFMul(C1, C2));
|
||||
}
|
||||
return ConstantVector::get(Res);
|
||||
case Instruction::UDiv:
|
||||
for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
|
||||
C1 = CP1 ? CP1->getOperand(i) : Constant::getNullValue(EltTy);
|
||||
C2 = CP2 ? CP2->getOperand(i) : Constant::getNullValue(EltTy);
|
||||
Res.push_back(ConstantExpr::getUDiv(const_cast<Constant*>(C1),
|
||||
const_cast<Constant*>(C2)));
|
||||
Res.push_back(ConstantExpr::getUDiv(C1, C2));
|
||||
}
|
||||
return ConstantVector::get(Res);
|
||||
case Instruction::SDiv:
|
||||
for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
|
||||
C1 = CP1 ? CP1->getOperand(i) : Constant::getNullValue(EltTy);
|
||||
C2 = CP2 ? CP2->getOperand(i) : Constant::getNullValue(EltTy);
|
||||
Res.push_back(ConstantExpr::getSDiv(const_cast<Constant*>(C1),
|
||||
const_cast<Constant*>(C2)));
|
||||
Res.push_back(ConstantExpr::getSDiv(C1, C2));
|
||||
}
|
||||
return ConstantVector::get(Res);
|
||||
case Instruction::FDiv:
|
||||
for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
|
||||
C1 = CP1 ? CP1->getOperand(i) : Constant::getNullValue(EltTy);
|
||||
C2 = CP2 ? CP2->getOperand(i) : Constant::getNullValue(EltTy);
|
||||
Res.push_back(ConstantExpr::getFDiv(const_cast<Constant*>(C1),
|
||||
const_cast<Constant*>(C2)));
|
||||
Res.push_back(ConstantExpr::getFDiv(C1, C2));
|
||||
}
|
||||
return ConstantVector::get(Res);
|
||||
case Instruction::URem:
|
||||
for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
|
||||
C1 = CP1 ? CP1->getOperand(i) : Constant::getNullValue(EltTy);
|
||||
C2 = CP2 ? CP2->getOperand(i) : Constant::getNullValue(EltTy);
|
||||
Res.push_back(ConstantExpr::getURem(const_cast<Constant*>(C1),
|
||||
const_cast<Constant*>(C2)));
|
||||
Res.push_back(ConstantExpr::getURem(C1, C2));
|
||||
}
|
||||
return ConstantVector::get(Res);
|
||||
case Instruction::SRem:
|
||||
for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
|
||||
C1 = CP1 ? CP1->getOperand(i) : Constant::getNullValue(EltTy);
|
||||
C2 = CP2 ? CP2->getOperand(i) : Constant::getNullValue(EltTy);
|
||||
Res.push_back(ConstantExpr::getSRem(const_cast<Constant*>(C1),
|
||||
const_cast<Constant*>(C2)));
|
||||
Res.push_back(ConstantExpr::getSRem(C1, C2));
|
||||
}
|
||||
return ConstantVector::get(Res);
|
||||
case Instruction::FRem:
|
||||
for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
|
||||
C1 = CP1 ? CP1->getOperand(i) : Constant::getNullValue(EltTy);
|
||||
C2 = CP2 ? CP2->getOperand(i) : Constant::getNullValue(EltTy);
|
||||
Res.push_back(ConstantExpr::getFRem(const_cast<Constant*>(C1),
|
||||
const_cast<Constant*>(C2)));
|
||||
Res.push_back(ConstantExpr::getFRem(C1, C2));
|
||||
}
|
||||
return ConstantVector::get(Res);
|
||||
case Instruction::And:
|
||||
for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
|
||||
C1 = CP1 ? CP1->getOperand(i) : Constant::getNullValue(EltTy);
|
||||
C2 = CP2 ? CP2->getOperand(i) : Constant::getNullValue(EltTy);
|
||||
Res.push_back(ConstantExpr::getAnd(const_cast<Constant*>(C1),
|
||||
const_cast<Constant*>(C2)));
|
||||
Res.push_back(ConstantExpr::getAnd(C1, C2));
|
||||
}
|
||||
return ConstantVector::get(Res);
|
||||
case Instruction::Or:
|
||||
for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
|
||||
C1 = CP1 ? CP1->getOperand(i) : Constant::getNullValue(EltTy);
|
||||
C2 = CP2 ? CP2->getOperand(i) : Constant::getNullValue(EltTy);
|
||||
Res.push_back(ConstantExpr::getOr(const_cast<Constant*>(C1),
|
||||
const_cast<Constant*>(C2)));
|
||||
Res.push_back(ConstantExpr::getOr(C1, C2));
|
||||
}
|
||||
return ConstantVector::get(Res);
|
||||
case Instruction::Xor:
|
||||
for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
|
||||
C1 = CP1 ? CP1->getOperand(i) : Constant::getNullValue(EltTy);
|
||||
C2 = CP2 ? CP2->getOperand(i) : Constant::getNullValue(EltTy);
|
||||
Res.push_back(ConstantExpr::getXor(const_cast<Constant*>(C1),
|
||||
const_cast<Constant*>(C2)));
|
||||
Res.push_back(ConstantExpr::getXor(C1, C2));
|
||||
}
|
||||
return ConstantVector::get(Res);
|
||||
case Instruction::LShr:
|
||||
for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
|
||||
C1 = CP1 ? CP1->getOperand(i) : Constant::getNullValue(EltTy);
|
||||
C2 = CP2 ? CP2->getOperand(i) : Constant::getNullValue(EltTy);
|
||||
Res.push_back(ConstantExpr::getLShr(const_cast<Constant*>(C1),
|
||||
const_cast<Constant*>(C2)));
|
||||
Res.push_back(ConstantExpr::getLShr(C1, C2));
|
||||
}
|
||||
return ConstantVector::get(Res);
|
||||
case Instruction::AShr:
|
||||
for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
|
||||
C1 = CP1 ? CP1->getOperand(i) : Constant::getNullValue(EltTy);
|
||||
C2 = CP2 ? CP2->getOperand(i) : Constant::getNullValue(EltTy);
|
||||
Res.push_back(ConstantExpr::getAShr(const_cast<Constant*>(C1),
|
||||
const_cast<Constant*>(C2)));
|
||||
Res.push_back(ConstantExpr::getAShr(C1, C2));
|
||||
}
|
||||
return ConstantVector::get(Res);
|
||||
case Instruction::Shl:
|
||||
for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
|
||||
C1 = CP1 ? CP1->getOperand(i) : Constant::getNullValue(EltTy);
|
||||
C2 = CP2 ? CP2->getOperand(i) : Constant::getNullValue(EltTy);
|
||||
Res.push_back(ConstantExpr::getShl(const_cast<Constant*>(C1),
|
||||
const_cast<Constant*>(C2)));
|
||||
Res.push_back(ConstantExpr::getShl(C1, C2));
|
||||
}
|
||||
return ConstantVector::get(Res);
|
||||
}
|
||||
@ -1015,22 +994,20 @@ Constant *llvm::ConstantFoldBinaryInstruction(LLVMContext &Context,
|
||||
switch (Opcode) {
|
||||
case Instruction::Add:
|
||||
case Instruction::Sub:
|
||||
return ConstantExpr::getXor(const_cast<Constant*>(C1),
|
||||
const_cast<Constant*>(C2));
|
||||
return ConstantExpr::getXor(C1, C2);
|
||||
case Instruction::Mul:
|
||||
return ConstantExpr::getAnd(const_cast<Constant*>(C1),
|
||||
const_cast<Constant*>(C2));
|
||||
return ConstantExpr::getAnd(C1, C2);
|
||||
case Instruction::Shl:
|
||||
case Instruction::LShr:
|
||||
case Instruction::AShr:
|
||||
// We can assume that C2 == 0. If it were one the result would be
|
||||
// undefined because the shift value is as large as the bitwidth.
|
||||
return const_cast<Constant*>(C1);
|
||||
return C1;
|
||||
case Instruction::SDiv:
|
||||
case Instruction::UDiv:
|
||||
// We can assume that C2 == 1. If it were zero the result would be
|
||||
// undefined through division by zero.
|
||||
return const_cast<Constant*>(C1);
|
||||
return C1;
|
||||
case Instruction::URem:
|
||||
case Instruction::SRem:
|
||||
// We can assume that C2 == 1. If it were zero the result would be
|
||||
@ -1114,8 +1091,7 @@ static int IdxCompare(LLVMContext &Context, Constant *C1, Constant *C2,
|
||||
/// operand is always the most "complex" of the two. We consider ConstantFP
|
||||
/// to be the simplest, and ConstantExprs to be the most complex.
|
||||
static FCmpInst::Predicate evaluateFCmpRelation(LLVMContext &Context,
|
||||
const Constant *V1,
|
||||
const Constant *V2) {
|
||||
Constant *V1, Constant *V2) {
|
||||
assert(V1->getType() == V2->getType() &&
|
||||
"Cannot compare values of different types!");
|
||||
|
||||
@ -1130,18 +1106,16 @@ static FCmpInst::Predicate evaluateFCmpRelation(LLVMContext &Context,
|
||||
if (!isa<ConstantExpr>(V2)) {
|
||||
// We distilled thisUse the standard constant folder for a few cases
|
||||
ConstantInt *R = 0;
|
||||
Constant *C1 = const_cast<Constant*>(V1);
|
||||
Constant *C2 = const_cast<Constant*>(V2);
|
||||
R = dyn_cast<ConstantInt>(
|
||||
ConstantExpr::getFCmp(FCmpInst::FCMP_OEQ, C1, C2));
|
||||
ConstantExpr::getFCmp(FCmpInst::FCMP_OEQ, V1, V2));
|
||||
if (R && !R->isZero())
|
||||
return FCmpInst::FCMP_OEQ;
|
||||
R = dyn_cast<ConstantInt>(
|
||||
ConstantExpr::getFCmp(FCmpInst::FCMP_OLT, C1, C2));
|
||||
ConstantExpr::getFCmp(FCmpInst::FCMP_OLT, V1, V2));
|
||||
if (R && !R->isZero())
|
||||
return FCmpInst::FCMP_OLT;
|
||||
R = dyn_cast<ConstantInt>(
|
||||
ConstantExpr::getFCmp(FCmpInst::FCMP_OGT, C1, C2));
|
||||
ConstantExpr::getFCmp(FCmpInst::FCMP_OGT, V1, V2));
|
||||
if (R && !R->isZero())
|
||||
return FCmpInst::FCMP_OGT;
|
||||
|
||||
@ -1156,7 +1130,7 @@ static FCmpInst::Predicate evaluateFCmpRelation(LLVMContext &Context,
|
||||
} else {
|
||||
// Ok, the LHS is known to be a constantexpr. The RHS can be any of a
|
||||
// constantexpr or a simple constant.
|
||||
const ConstantExpr *CE1 = cast<ConstantExpr>(V1);
|
||||
ConstantExpr *CE1 = cast<ConstantExpr>(V1);
|
||||
switch (CE1->getOpcode()) {
|
||||
case Instruction::FPTrunc:
|
||||
case Instruction::FPExt:
|
||||
@ -1186,8 +1160,8 @@ static FCmpInst::Predicate evaluateFCmpRelation(LLVMContext &Context,
|
||||
/// GlobalValues, followed by ConstantExpr's (the most complex).
|
||||
///
|
||||
static ICmpInst::Predicate evaluateICmpRelation(LLVMContext &Context,
|
||||
const Constant *V1,
|
||||
const Constant *V2,
|
||||
Constant *V1,
|
||||
Constant *V2,
|
||||
bool isSigned) {
|
||||
assert(V1->getType() == V2->getType() &&
|
||||
"Cannot compare different types of values!");
|
||||
@ -1198,18 +1172,16 @@ static ICmpInst::Predicate evaluateICmpRelation(LLVMContext &Context,
|
||||
// We distilled this down to a simple case, use the standard constant
|
||||
// folder.
|
||||
ConstantInt *R = 0;
|
||||
Constant *C1 = const_cast<Constant*>(V1);
|
||||
Constant *C2 = const_cast<Constant*>(V2);
|
||||
ICmpInst::Predicate pred = ICmpInst::ICMP_EQ;
|
||||
R = dyn_cast<ConstantInt>(ConstantExpr::getICmp(pred, C1, C2));
|
||||
R = dyn_cast<ConstantInt>(ConstantExpr::getICmp(pred, V1, V2));
|
||||
if (R && !R->isZero())
|
||||
return pred;
|
||||
pred = isSigned ? ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT;
|
||||
R = dyn_cast<ConstantInt>(ConstantExpr::getICmp(pred, C1, C2));
|
||||
R = dyn_cast<ConstantInt>(ConstantExpr::getICmp(pred, V1, V2));
|
||||
if (R && !R->isZero())
|
||||
return pred;
|
||||
pred = isSigned ? ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT;
|
||||
R = dyn_cast<ConstantInt>(ConstantExpr::getICmp(pred, C1, C2));
|
||||
R = dyn_cast<ConstantInt>(ConstantExpr::getICmp(pred, V1, V2));
|
||||
if (R && !R->isZero())
|
||||
return pred;
|
||||
|
||||
@ -1249,8 +1221,8 @@ static ICmpInst::Predicate evaluateICmpRelation(LLVMContext &Context,
|
||||
} else {
|
||||
// Ok, the LHS is known to be a constantexpr. The RHS can be any of a
|
||||
// constantexpr, a CPR, or a simple constant.
|
||||
const ConstantExpr *CE1 = cast<ConstantExpr>(V1);
|
||||
const Constant *CE1Op0 = CE1->getOperand(0);
|
||||
ConstantExpr *CE1 = cast<ConstantExpr>(V1);
|
||||
Constant *CE1Op0 = CE1->getOperand(0);
|
||||
|
||||
switch (CE1->getOpcode()) {
|
||||
case Instruction::Trunc:
|
||||
@ -1281,7 +1253,7 @@ static ICmpInst::Predicate evaluateICmpRelation(LLVMContext &Context,
|
||||
// from the same type as the src of the LHS, evaluate the inputs. This is
|
||||
// important for things like "icmp eq (cast 4 to int*), (cast 5 to int*)",
|
||||
// which happens a lot in compilers with tagged integers.
|
||||
if (const ConstantExpr *CE2 = dyn_cast<ConstantExpr>(V2))
|
||||
if (ConstantExpr *CE2 = dyn_cast<ConstantExpr>(V2))
|
||||
if (CE2->isCast() && isa<PointerType>(CE1->getType()) &&
|
||||
CE1->getOperand(0)->getType() == CE2->getOperand(0)->getType() &&
|
||||
CE1->getOperand(0)->getType()->isInteger()) {
|
||||
@ -1346,8 +1318,8 @@ static ICmpInst::Predicate evaluateICmpRelation(LLVMContext &Context,
|
||||
}
|
||||
}
|
||||
} else {
|
||||
const ConstantExpr *CE2 = cast<ConstantExpr>(V2);
|
||||
const Constant *CE2Op0 = CE2->getOperand(0);
|
||||
ConstantExpr *CE2 = cast<ConstantExpr>(V2);
|
||||
Constant *CE2Op0 = CE2->getOperand(0);
|
||||
|
||||
// There are MANY other foldings that we could perform here. They will
|
||||
// probably be added on demand, as they seem needed.
|
||||
@ -1414,8 +1386,7 @@ static ICmpInst::Predicate evaluateICmpRelation(LLVMContext &Context,
|
||||
|
||||
Constant *llvm::ConstantFoldCompareInstruction(LLVMContext &Context,
|
||||
unsigned short pred,
|
||||
const Constant *C1,
|
||||
const Constant *C2) {
|
||||
Constant *C1, Constant *C2) {
|
||||
const Type *ResultTy;
|
||||
if (const VectorType *VT = dyn_cast<VectorType>(C1->getType()))
|
||||
ResultTy = VectorType::get(Type::getInt1Ty(Context), VT->getNumElements());
|
||||
@ -1728,13 +1699,13 @@ static bool isInBoundsIndices(Constant *const *Idxs, size_t NumIdx) {
|
||||
}
|
||||
|
||||
Constant *llvm::ConstantFoldGetElementPtr(LLVMContext &Context,
|
||||
const Constant *C,
|
||||
Constant *C,
|
||||
bool inBounds,
|
||||
Constant* const *Idxs,
|
||||
unsigned NumIdx) {
|
||||
if (NumIdx == 0 ||
|
||||
(NumIdx == 1 && Idxs[0]->isNullValue()))
|
||||
return const_cast<Constant*>(C);
|
||||
return C;
|
||||
|
||||
if (isa<UndefValue>(C)) {
|
||||
const PointerType *Ptr = cast<PointerType>(C->getType());
|
||||
@ -1764,7 +1735,7 @@ Constant *llvm::ConstantFoldGetElementPtr(LLVMContext &Context,
|
||||
}
|
||||
}
|
||||
|
||||
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(const_cast<Constant*>(C))) {
|
||||
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) {
|
||||
// Combine Indices - If the source pointer to this getelementptr instruction
|
||||
// is a getelementptr instruction, combine the indices of the two
|
||||
// getelementptr instructions into a single instruction.
|
||||
@ -1904,18 +1875,16 @@ Constant *llvm::ConstantFoldGetElementPtr(LLVMContext &Context,
|
||||
for (unsigned i = 0; i != NumIdx; ++i)
|
||||
if (!NewIdxs[i]) NewIdxs[i] = Idxs[i];
|
||||
return inBounds ?
|
||||
ConstantExpr::getInBoundsGetElementPtr(const_cast<Constant*>(C),
|
||||
NewIdxs.data(), NewIdxs.size()) :
|
||||
ConstantExpr::getGetElementPtr(const_cast<Constant*>(C),
|
||||
NewIdxs.data(), NewIdxs.size());
|
||||
ConstantExpr::getInBoundsGetElementPtr(C, NewIdxs.data(),
|
||||
NewIdxs.size()) :
|
||||
ConstantExpr::getGetElementPtr(C, NewIdxs.data(), NewIdxs.size());
|
||||
}
|
||||
|
||||
// If all indices are known integers and normalized, we can do a simple
|
||||
// check for the "inbounds" property.
|
||||
if (!Unknown && !inBounds &&
|
||||
isa<GlobalVariable>(C) && isInBoundsIndices(Idxs, NumIdx))
|
||||
return ConstantExpr::getInBoundsGetElementPtr(const_cast<Constant*>(C),
|
||||
Idxs, NumIdx);
|
||||
return ConstantExpr::getInBoundsGetElementPtr(C, Idxs, NumIdx);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -29,41 +29,39 @@ namespace llvm {
|
||||
Constant *ConstantFoldCastInstruction(
|
||||
LLVMContext &Context,
|
||||
unsigned opcode, ///< The opcode of the cast
|
||||
const Constant *V, ///< The source constant
|
||||
Constant *V, ///< The source constant
|
||||
const Type *DestTy ///< The destination type
|
||||
);
|
||||
Constant *ConstantFoldSelectInstruction(LLVMContext &Context,
|
||||
const Constant *Cond,
|
||||
const Constant *V1,
|
||||
const Constant *V2);
|
||||
Constant *Cond,
|
||||
Constant *V1, Constant *V2);
|
||||
Constant *ConstantFoldExtractElementInstruction(LLVMContext &Context,
|
||||
const Constant *Val,
|
||||
const Constant *Idx);
|
||||
Constant *Val,
|
||||
Constant *Idx);
|
||||
Constant *ConstantFoldInsertElementInstruction(LLVMContext &Context,
|
||||
const Constant *Val,
|
||||
const Constant *Elt,
|
||||
const Constant *Idx);
|
||||
Constant *Val,
|
||||
Constant *Elt,
|
||||
Constant *Idx);
|
||||
Constant *ConstantFoldShuffleVectorInstruction(LLVMContext &Context,
|
||||
const Constant *V1,
|
||||
const Constant *V2,
|
||||
const Constant *Mask);
|
||||
Constant *V1,
|
||||
Constant *V2,
|
||||
Constant *Mask);
|
||||
Constant *ConstantFoldExtractValueInstruction(LLVMContext &Context,
|
||||
const Constant *Agg,
|
||||
Constant *Agg,
|
||||
const unsigned *Idxs,
|
||||
unsigned NumIdx);
|
||||
Constant *ConstantFoldInsertValueInstruction(LLVMContext &Context,
|
||||
const Constant *Agg,
|
||||
const Constant *Val,
|
||||
const unsigned* Idxs,
|
||||
Constant *Agg,
|
||||
Constant *Val,
|
||||
const unsigned *Idxs,
|
||||
unsigned NumIdx);
|
||||
Constant *ConstantFoldBinaryInstruction(LLVMContext &Context,
|
||||
unsigned Opcode, const Constant *V1,
|
||||
const Constant *V2);
|
||||
unsigned Opcode, Constant *V1,
|
||||
Constant *V2);
|
||||
Constant *ConstantFoldCompareInstruction(LLVMContext &Context,
|
||||
unsigned short predicate,
|
||||
const Constant *C1,
|
||||
const Constant *C2);
|
||||
Constant *ConstantFoldGetElementPtr(LLVMContext &Context, const Constant *C,
|
||||
Constant *C1, Constant *C2);
|
||||
Constant *ConstantFoldGetElementPtr(LLVMContext &Context, Constant *C,
|
||||
bool inBounds,
|
||||
Constant* const *Idxs, unsigned NumIdx);
|
||||
} // End llvm namespace
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user