6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-08-06 05:29:55 +00:00
Code Issues Projects Releases Wiki Activity

Value* were never meant to be const. Removing constness from the constant

Browse Source 
folder removes a lot of const_casting and requires no changes to clang or
llvm-gcc.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@82349 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Nick Lewycky 2009-09-20 01:35:59 +00:00
parent b7b71a37a1
commit 33c06adcf1
2 changed files with 150 additions and 183 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

293
lib/VMCore/ConstantFold.cpp
View File

@ -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;
}

40
lib/VMCore/ConstantFold.h
View File

@ -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