//===- ConstantHandling.cpp - Implement ConstantHandling.h ----------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
//
// This file implements the various intrinsic operations, on constant values.
//
#include "llvm/ConstantHandling.h"
#include "llvm/iPHINode.h"
+#include "llvm/InstrTypes.h"
#include "llvm/DerivedTypes.h"
#include <cmath>
-
-AnnotationID ConstRules::AID(AnnotationManager::getID("opt::ConstRules",
- &ConstRules::find));
+using namespace llvm;
// ConstantFoldInstruction - Attempt to constant fold the specified instruction.
// If successful, the constant result is returned, if not, null is returned.
//
-Constant *ConstantFoldInstruction(Instruction *I) {
+Constant *llvm::ConstantFoldInstruction(Instruction *I) {
if (PHINode *PN = dyn_cast<PHINode>(I)) {
if (PN->getNumIncomingValues() == 0)
return Constant::getNullValue(PN->getType());
}
}
+ if (isa<BinaryOperator>(I))
+ return ConstantExpr::get(I->getOpcode(), Op0, Op1);
+
switch (I->getOpcode()) {
case Instruction::Cast:
- return ConstRules::get(*Op0)->castTo(Op0, I->getType());
- case Instruction::Add: return *Op0 + *Op1;
- case Instruction::Sub: return *Op0 - *Op1;
- case Instruction::Mul: return *Op0 * *Op1;
- case Instruction::Div: return *Op0 / *Op1;
- case Instruction::Rem: return *Op0 % *Op1;
- case Instruction::And: return *Op0 & *Op1;
- case Instruction::Or: return *Op0 | *Op1;
- case Instruction::Xor: return *Op0 ^ *Op1;
-
- case Instruction::SetEQ: return *Op0 == *Op1;
- case Instruction::SetNE: return *Op0 != *Op1;
- case Instruction::SetLE: return *Op0 <= *Op1;
- case Instruction::SetGE: return *Op0 >= *Op1;
- case Instruction::SetLT: return *Op0 < *Op1;
- case Instruction::SetGT: return *Op0 > *Op1;
- case Instruction::Shl: return *Op0 << *Op1;
- case Instruction::Shr: return *Op0 >> *Op1;
+ return ConstantExpr::getCast(Op0, I->getType());
+ case Instruction::Shl:
+ case Instruction::Shr:
+ return ConstantExpr::getShift(I->getOpcode(), Op0, Op1);
case Instruction::GetElementPtr: {
std::vector<Constant*> IdxList;
IdxList.reserve(I->getNumOperands()-1);
IdxList.push_back(C);
else
return 0; // Non-constant operand
- return ConstantFoldGetElementPtr(Op0, IdxList);
+ return ConstantExpr::getGetElementPtr(Op0, IdxList);
}
default:
return 0;
return S ? S : 8; // Treat pointers at 8 bytes
}
-Constant *ConstantFoldCastInstruction(const Constant *V, const Type *DestTy) {
+Constant *llvm::ConstantFoldCastInstruction(const Constant *V,
+ const Type *DestTy) {
if (V->getType() == DestTy) return (Constant*)V;
if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(V))
if (CE->getOpcode() == Instruction::Cast) {
- Constant *Op = (Constant*)cast<Constant>(CE->getOperand(0));
+ Constant *Op = const_cast<Constant*>(CE->getOperand(0));
// Try to not produce a cast of a cast, which is almost always redundant.
if (!Op->getType()->isFloatingPoint() &&
!CE->getType()->isFloatingPoint() &&
if (S1 <= S2 && S2 >= S3 && S1 <= S3)
return ConstantExpr::getCast(Op, DestTy);
}
+ } else if (CE->getOpcode() == Instruction::GetElementPtr) {
+ // If all of the indexes in the GEP are null values, there is no pointer
+ // adjustment going on. We might as well cast the source pointer.
+ bool isAllNull = true;
+ for (unsigned i = 1, e = CE->getNumOperands(); i != e; ++i)
+ if (!CE->getOperand(i)->isNullValue()) {
+ isAllNull = false;
+ break;
+ }
+ if (isAllNull)
+ return ConstantExpr::getCast(CE->getOperand(0), DestTy);
}
- return ConstRules::get(*V)->castTo(V, DestTy);
+ return ConstRules::get(*V, *V).castTo(V, DestTy);
}
-Constant *ConstantFoldBinaryInstruction(unsigned Opcode, const Constant *V1,
- const Constant *V2) {
+Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode,
+ const Constant *V1,
+ const Constant *V2) {
switch (Opcode) {
case Instruction::Add: return *V1 + *V2;
case Instruction::Sub: return *V1 - *V2;
return 0;
}
-Constant *ConstantFoldShiftInstruction(unsigned Opcode, const Constant *V1,
- const Constant *V2) {
+Constant *llvm::ConstantFoldShiftInstruction(unsigned Opcode,
+ const Constant *V1,
+ const Constant *V2) {
switch (Opcode) {
case Instruction::Shl: return *V1 << *V2;
case Instruction::Shr: return *V1 >> *V2;
}
}
-Constant *ConstantFoldGetElementPtr(const Constant *C,
- const std::vector<Constant*> &IdxList) {
+Constant *llvm::ConstantFoldGetElementPtr(const Constant *C,
+ const std::vector<Constant*> &IdxList) {
if (IdxList.size() == 0 ||
(IdxList.size() == 1 && IdxList[0]->isNullValue()))
return const_cast<Constant*>(C);
- // If C is null and all idx's are null, return null of the right type.
+ // TODO If C is null and all idx's are null, return null of the right type.
+
+
+ if (const 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.
+ //
+ if (CE->getOpcode() == Instruction::GetElementPtr) {
+ if (CE->getOperand(CE->getNumOperands()-1)->getType() == Type::LongTy) {
+ std::vector<Constant*> NewIndices;
+ NewIndices.reserve(IdxList.size() + CE->getNumOperands());
+ for (unsigned i = 1, e = CE->getNumOperands()-1; i != e; ++i)
+ NewIndices.push_back(cast<Constant>(CE->getOperand(i)));
+
+ // Add the last index of the source with the first index of the new GEP.
+ Constant *Combined =
+ ConstantExpr::get(Instruction::Add, IdxList[0],
+ CE->getOperand(CE->getNumOperands()-1));
+
+ NewIndices.push_back(Combined);
+ NewIndices.insert(NewIndices.end(), IdxList.begin()+1, IdxList.end());
+ return ConstantExpr::getGetElementPtr(CE->getOperand(0), NewIndices);
+ }
+ }
- // FIXME: Implement folding of GEP constant exprs the same as instcombine does
+ // Implement folding of:
+ // int* getelementptr ([2 x int]* cast ([3 x int]* %X to [2 x int]*),
+ // long 0, long 0)
+ // To: int* getelementptr ([3 x int]* %X, long 0, long 0)
+ //
+ if (CE->getOpcode() == Instruction::Cast && IdxList.size() > 1 &&
+ IdxList[0]->isNullValue())
+ if (const PointerType *SPT =
+ dyn_cast<PointerType>(CE->getOperand(0)->getType()))
+ if (const ArrayType *SAT = dyn_cast<ArrayType>(SPT->getElementType()))
+ if (const ArrayType *CAT =
+ dyn_cast<ArrayType>(cast<PointerType>(C->getType())->getElementType()))
+ if (CAT->getElementType() == SAT->getElementType())
+ return ConstantExpr::getGetElementPtr(
+ (Constant*)CE->getOperand(0), IdxList);
+ }
return 0;
}
static Constant *Xor(const ConstantBool *V1, const ConstantBool *V2) {
return ConstantBool::get(V1->getValue() ^ V2->getValue());
}
+
+ // Casting operators. ick
+#define DEF_CAST(TYPE, CLASS, CTYPE) \
+ static CLASS *CastTo##TYPE (const ConstantBool *V) { \
+ return CLASS::get(Type::TYPE##Ty, (CTYPE)(bool)V->getValue()); \
+ }
+
+ DEF_CAST(Bool , ConstantBool, bool)
+ DEF_CAST(SByte , ConstantSInt, signed char)
+ DEF_CAST(UByte , ConstantUInt, unsigned char)
+ DEF_CAST(Short , ConstantSInt, signed short)
+ DEF_CAST(UShort, ConstantUInt, unsigned short)
+ DEF_CAST(Int , ConstantSInt, signed int)
+ DEF_CAST(UInt , ConstantUInt, unsigned int)
+ DEF_CAST(Long , ConstantSInt, int64_t)
+ DEF_CAST(ULong , ConstantUInt, uint64_t)
+ DEF_CAST(Float , ConstantFP , float)
+ DEF_CAST(Double, ConstantFP , double)
+#undef DEF_CAST
};
//===----------------------------------------------------------------------===//
-// PointerRules Class
+// NullPointerRules Class
//===----------------------------------------------------------------------===//
//
-// PointerRules provides a concrete base class of ConstRules for pointer types
+// NullPointerRules provides a concrete base class of ConstRules for null
+// pointers.
//
-struct PointerRules : public TemplateRules<ConstantPointer, PointerRules> {
+struct NullPointerRules : public TemplateRules<ConstantPointer,
+ NullPointerRules> {
static ConstantBool *CastToBool (const Constant *V) {
- if (V->isNullValue()) return ConstantBool::False;
- return 0; // Can't const prop other types of pointers
+ return ConstantBool::False;
}
static ConstantSInt *CastToSByte (const Constant *V) {
- if (V->isNullValue()) return ConstantSInt::get(Type::SByteTy, 0);
- return 0; // Can't const prop other types of pointers
+ return ConstantSInt::get(Type::SByteTy, 0);
}
static ConstantUInt *CastToUByte (const Constant *V) {
- if (V->isNullValue()) return ConstantUInt::get(Type::UByteTy, 0);
- return 0; // Can't const prop other types of pointers
+ return ConstantUInt::get(Type::UByteTy, 0);
}
static ConstantSInt *CastToShort (const Constant *V) {
- if (V->isNullValue()) return ConstantSInt::get(Type::ShortTy, 0);
- return 0; // Can't const prop other types of pointers
+ return ConstantSInt::get(Type::ShortTy, 0);
}
static ConstantUInt *CastToUShort(const Constant *V) {
- if (V->isNullValue()) return ConstantUInt::get(Type::UShortTy, 0);
- return 0; // Can't const prop other types of pointers
+ return ConstantUInt::get(Type::UShortTy, 0);
}
static ConstantSInt *CastToInt (const Constant *V) {
- if (V->isNullValue()) return ConstantSInt::get(Type::IntTy, 0);
- return 0; // Can't const prop other types of pointers
+ return ConstantSInt::get(Type::IntTy, 0);
}
static ConstantUInt *CastToUInt (const Constant *V) {
- if (V->isNullValue()) return ConstantUInt::get(Type::UIntTy, 0);
- return 0; // Can't const prop other types of pointers
+ return ConstantUInt::get(Type::UIntTy, 0);
}
static ConstantSInt *CastToLong (const Constant *V) {
- if (V->isNullValue()) return ConstantSInt::get(Type::LongTy, 0);
- return 0; // Can't const prop other types of pointers
+ return ConstantSInt::get(Type::LongTy, 0);
}
static ConstantUInt *CastToULong (const Constant *V) {
- if (V->isNullValue()) return ConstantUInt::get(Type::ULongTy, 0);
- return 0; // Can't const prop other types of pointers
+ return ConstantUInt::get(Type::ULongTy, 0);
}
static ConstantFP *CastToFloat (const Constant *V) {
- if (V->isNullValue()) return ConstantFP::get(Type::FloatTy, 0);
- return 0; // Can't const prop other types of pointers
+ return ConstantFP::get(Type::FloatTy, 0);
}
static ConstantFP *CastToDouble(const Constant *V) {
- if (V->isNullValue()) return ConstantFP::get(Type::DoubleTy, 0);
- return 0; // Can't const prop other types of pointers
+ return ConstantFP::get(Type::DoubleTy, 0);
}
static Constant *CastToPointer(const ConstantPointer *V,
const PointerType *PTy) {
- if (V->getType() == PTy)
- return const_cast<ConstantPointer*>(V); // Allow cast %PTy %ptr to %PTy
- if (V->isNullValue())
- return ConstantPointerNull::get(PTy);
- return 0; // Can't const prop other types of pointers
+ return ConstantPointerNull::get(PTy);
}
};
: public DirectRules<ConstantClass, BuiltinType, Ty,
DirectIntRules<ConstantClass, BuiltinType, Ty> > {
+ static Constant *Div(const ConstantClass *V1, const ConstantClass *V2) {
+ if (V2->isNullValue()) return 0;
+ if (V2->isAllOnesValue() && // MIN_INT / -1
+ (BuiltinType)V1->getValue() == -(BuiltinType)V1->getValue())
+ return 0;
+ BuiltinType R = (BuiltinType)V1->getValue() / (BuiltinType)V2->getValue();
+ return ConstantClass::get(*Ty, R);
+ }
+
static Constant *Rem(const ConstantClass *V1,
const ConstantClass *V2) {
- if (V2->isNullValue()) return 0;
+ if (V2->isNullValue()) return 0; // X / 0
+ if (V2->isAllOnesValue() && // MIN_INT / -1
+ (BuiltinType)V1->getValue() == -(BuiltinType)V1->getValue())
+ return 0;
BuiltinType R = (BuiltinType)V1->getValue() % (BuiltinType)V2->getValue();
return ConstantClass::get(*Ty, R);
}
}
};
-//===----------------------------------------------------------------------===//
-// DirectRules Subclasses
-//===----------------------------------------------------------------------===//
-//
-// Given the DirectRules class we can now implement lots of types with little
-// code. Thank goodness C++ compilers are great at stomping out layers of
-// templates... can you imagine having to do this all by hand? (/me is lazy :)
-//
-
-// ConstRules::find - Return the constant rules that take care of the specified
-// type.
-//
-Annotation *ConstRules::find(AnnotationID AID, const Annotable *TyA, void *) {
- assert(AID == ConstRules::AID && "Bad annotation for factory!");
- const Type *Ty = cast<Type>((const Value*)TyA);
-
- switch (Ty->getPrimitiveID()) {
- case Type::BoolTyID: return new BoolRules();
- case Type::PointerTyID: return new PointerRules();
- case Type::SByteTyID:
- return new DirectIntRules<ConstantSInt, signed char , &Type::SByteTy>();
- case Type::UByteTyID:
- return new DirectIntRules<ConstantUInt, unsigned char , &Type::UByteTy>();
- case Type::ShortTyID:
- return new DirectIntRules<ConstantSInt, signed short, &Type::ShortTy>();
- case Type::UShortTyID:
- return new DirectIntRules<ConstantUInt, unsigned short, &Type::UShortTy>();
- case Type::IntTyID:
- return new DirectIntRules<ConstantSInt, signed int , &Type::IntTy>();
- case Type::UIntTyID:
- return new DirectIntRules<ConstantUInt, unsigned int , &Type::UIntTy>();
- case Type::LongTyID:
- return new DirectIntRules<ConstantSInt, int64_t , &Type::LongTy>();
- case Type::ULongTyID:
- return new DirectIntRules<ConstantUInt, uint64_t , &Type::ULongTy>();
- case Type::FloatTyID:
- return new DirectFPRules<ConstantFP , float , &Type::FloatTy>();
- case Type::DoubleTyID:
- return new DirectFPRules<ConstantFP , double , &Type::DoubleTy>();
- default:
- return new EmptyRules();
+ConstRules &ConstRules::get(const Constant &V1, const Constant &V2) {
+ static EmptyRules EmptyR;
+ static BoolRules BoolR;
+ static NullPointerRules NullPointerR;
+ static DirectIntRules<ConstantSInt, signed char , &Type::SByteTy> SByteR;
+ static DirectIntRules<ConstantUInt, unsigned char , &Type::UByteTy> UByteR;
+ static DirectIntRules<ConstantSInt, signed short, &Type::ShortTy> ShortR;
+ static DirectIntRules<ConstantUInt, unsigned short, &Type::UShortTy> UShortR;
+ static DirectIntRules<ConstantSInt, signed int , &Type::IntTy> IntR;
+ static DirectIntRules<ConstantUInt, unsigned int , &Type::UIntTy> UIntR;
+ static DirectIntRules<ConstantSInt, int64_t , &Type::LongTy> LongR;
+ static DirectIntRules<ConstantUInt, uint64_t , &Type::ULongTy> ULongR;
+ static DirectFPRules <ConstantFP , float , &Type::FloatTy> FloatR;
+ static DirectFPRules <ConstantFP , double , &Type::DoubleTy> DoubleR;
+
+ if (isa<ConstantExpr>(V1) || isa<ConstantExpr>(V2) ||
+ isa<ConstantPointerRef>(V1) || isa<ConstantPointerRef>(V2))
+ return EmptyR;
+
+ // FIXME: This assert doesn't work because shifts pass both operands in to
+ // check for constant exprs. :(
+ //assert(V1.getType() == V2.getType() &&"Nonequal types to constant folder?");
+
+ switch (V1.getType()->getPrimitiveID()) {
+ default: assert(0 && "Unknown value type for constant folding!");
+ case Type::BoolTyID: return BoolR;
+ case Type::PointerTyID: return NullPointerR;
+ case Type::SByteTyID: return SByteR;
+ case Type::UByteTyID: return UByteR;
+ case Type::ShortTyID: return ShortR;
+ case Type::UShortTyID: return UShortR;
+ case Type::IntTyID: return IntR;
+ case Type::UIntTyID: return UIntR;
+ case Type::LongTyID: return LongR;
+ case Type::ULongTyID: return ULongR;
+ case Type::FloatTyID: return FloatR;
+ case Type::DoubleTyID: return DoubleR;
}
}
projects / oota-llvm.git / blobdiff