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

38
lib/VMCore/ConstantFold.h
View File

@ -29,41 +29,39 @@ namespace llvm {
Constant *ConstantFoldCastInstruction( Constant *ConstantFoldCastInstruction(
LLVMContext &Context, LLVMContext &Context,
unsigned opcode, ///< The opcode of the cast unsigned opcode, ///< The opcode of the cast
const Constant *V, ///< The source constant Constant *V, ///< The source constant
const Type *DestTy ///< The destination type const Type *DestTy ///< The destination type
); );
Constant *ConstantFoldSelectInstruction(LLVMContext &Context, Constant *ConstantFoldSelectInstruction(LLVMContext &Context,
const Constant *Cond, Constant *Cond,
const Constant *V1, Constant *V1, Constant *V2);
const Constant *V2);
Constant *ConstantFoldExtractElementInstruction(LLVMContext &Context, Constant *ConstantFoldExtractElementInstruction(LLVMContext &Context,
const Constant *Val, Constant *Val,
const Constant *Idx); Constant *Idx);
Constant *ConstantFoldInsertElementInstruction(LLVMContext &Context, Constant *ConstantFoldInsertElementInstruction(LLVMContext &Context,
const Constant *Val, Constant *Val,
const Constant *Elt, Constant *Elt,
const Constant *Idx); Constant *Idx);
Constant *ConstantFoldShuffleVectorInstruction(LLVMContext &Context, Constant *ConstantFoldShuffleVectorInstruction(LLVMContext &Context,
const Constant *V1, Constant *V1,
const Constant *V2, Constant *V2,
const Constant *Mask); Constant *Mask);
Constant *ConstantFoldExtractValueInstruction(LLVMContext &Context, Constant *ConstantFoldExtractValueInstruction(LLVMContext &Context,
const Constant *Agg, Constant *Agg,
const unsigned *Idxs, const unsigned *Idxs,
unsigned NumIdx); unsigned NumIdx);
Constant *ConstantFoldInsertValueInstruction(LLVMContext &Context, Constant *ConstantFoldInsertValueInstruction(LLVMContext &Context,
const Constant *Agg, Constant *Agg,
const Constant *Val, Constant *Val,
const unsigned *Idxs, const unsigned *Idxs,
unsigned NumIdx); unsigned NumIdx);
Constant *ConstantFoldBinaryInstruction(LLVMContext &Context, Constant *ConstantFoldBinaryInstruction(LLVMContext &Context,
unsigned Opcode, const Constant *V1, unsigned Opcode, Constant *V1,
const Constant *V2); Constant *V2);
Constant *ConstantFoldCompareInstruction(LLVMContext &Context, Constant *ConstantFoldCompareInstruction(LLVMContext &Context,
unsigned short predicate, unsigned short predicate,
const Constant *C1, Constant *C1, Constant *C2);
const Constant *C2); Constant *ConstantFoldGetElementPtr(LLVMContext &Context, Constant *C,
Constant *ConstantFoldGetElementPtr(LLVMContext &Context, const Constant *C,
bool inBounds, bool inBounds,
Constant* const *Idxs, unsigned NumIdx); Constant* const *Idxs, unsigned NumIdx);
} // End llvm namespace } // End llvm namespace