//===----------------------------------------------------------------------===//
#include "llvm/Constants.h"
-#include "ConstantFolding.h"
+#include "ConstantFold.h"
#include "llvm/DerivedTypes.h"
#include "llvm/GlobalValue.h"
#include "llvm/Instructions.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/ManagedStatic.h"
#include "llvm/Support/MathExtras.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/SmallVector.h"
#include <algorithm>
#include <map>
using namespace llvm;
}
}
+/// ContaintsRelocations - Return true if the constant value contains
+/// relocations which cannot be resolved at compile time.
+bool Constant::ContainsRelocations() const {
+ if (isa<GlobalValue>(this))
+ return true;
+ for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
+ if (getOperand(i)->ContainsRelocations())
+ return true;
+ return false;
+}
// Static constructor to create a '0' constant of arbitrary type...
Constant *Constant::getNullValue(const Type *Ty) {
switch (Ty->getTypeID()) {
- case Type::IntegerTyID: {
- const IntegerType *ITy = dyn_cast<IntegerType>(Ty);
- switch (ITy->getBitWidth()) {
- case 1: {
- static Constant *NullBool = ConstantInt::get(Ty, false);
- return NullBool;
- }
- case 8: {
- static Constant *NullInt8 = ConstantInt::get(Ty, 0);
- return NullInt8;
- }
- case 16: {
- static Constant *NullInt16 = ConstantInt::get(Ty, 0);
- return NullInt16;
- }
- case 32: {
- static Constant *NullInt32 = ConstantInt::get(Ty, 0);
- return NullInt32;
- }
- case 64: {
- static Constant *NullInt64 = ConstantInt::get(Ty, 0);
- return NullInt64;
- }
- default:
- return ConstantInt::get(Ty, 0);
- }
- }
- case Type::FloatTyID: {
- static Constant *NullFloat = ConstantFP::get(Type::FloatTy, 0);
- return NullFloat;
- }
- case Type::DoubleTyID: {
- static Constant *NullDouble = ConstantFP::get(Type::DoubleTy, 0);
- return NullDouble;
- }
+ case Type::IntegerTyID:
+ return ConstantInt::get(Ty, 0);
+ case Type::FloatTyID:
+ case Type::DoubleTyID:
+ case Type::X86_FP80TyID:
+ case Type::PPC_FP128TyID:
+ case Type::FP128TyID:
+ return ConstantFP::get(Ty, 0.0);
case Type::PointerTyID:
return ConstantPointerNull::get(cast<PointerType>(Ty));
case Type::StructTyID:
}
}
+Constant *Constant::getAllOnesValue(const Type *Ty) {
+ if (const IntegerType* ITy = dyn_cast<IntegerType>(Ty))
+ return ConstantInt::get(APInt::getAllOnesValue(ITy->getBitWidth()));
+ return ConstantVector::getAllOnesValue(cast<VectorType>(Ty));
+}
// Static constructor to create an integral constant with all bits set
ConstantInt *ConstantInt::getAllOnesValue(const Type *Ty) {
if (const IntegerType* ITy = dyn_cast<IntegerType>(Ty))
- if (ITy->getBitWidth() == 1)
- return ConstantInt::getTrue();
- else
- return ConstantInt::get(Ty, int64_t(-1));
+ return ConstantInt::get(APInt::getAllOnesValue(ITy->getBitWidth()));
return 0;
}
-/// @returns the value for an packed integer constant of the given type that
+/// @returns the value for a vector integer constant of the given type that
/// has all its bits set to true.
/// @brief Get the all ones value
ConstantVector *ConstantVector::getAllOnesValue(const VectorType *Ty) {
std::vector<Constant*> Elts;
Elts.resize(Ty->getNumElements(),
ConstantInt::getAllOnesValue(Ty->getElementType()));
- assert(Elts[0] && "Not a packed integer type!");
+ assert(Elts[0] && "Not a vector integer type!");
return cast<ConstantVector>(ConstantVector::get(Elts));
}
//===----------------------------------------------------------------------===//
-// ConstantXXX Classes
+// ConstantInt
//===----------------------------------------------------------------------===//
-//===----------------------------------------------------------------------===//
-// Normal Constructors
+ConstantInt::ConstantInt(const IntegerType *Ty, const APInt& V)
+ : Constant(Ty, ConstantIntVal, 0, 0), Val(V) {
+ assert(V.getBitWidth() == Ty->getBitWidth() && "Invalid constant for type");
+}
+
+ConstantInt *ConstantInt::TheTrueVal = 0;
+ConstantInt *ConstantInt::TheFalseVal = 0;
+
+namespace llvm {
+ void CleanupTrueFalse(void *) {
+ ConstantInt::ResetTrueFalse();
+ }
+}
+
+static ManagedCleanup<llvm::CleanupTrueFalse> TrueFalseCleanup;
+
+ConstantInt *ConstantInt::CreateTrueFalseVals(bool WhichOne) {
+ assert(TheTrueVal == 0 && TheFalseVal == 0);
+ TheTrueVal = get(Type::Int1Ty, 1);
+ TheFalseVal = get(Type::Int1Ty, 0);
+
+ // Ensure that llvm_shutdown nulls out TheTrueVal/TheFalseVal.
+ TrueFalseCleanup.Register();
+
+ return WhichOne ? TheTrueVal : TheFalseVal;
+}
+
-ConstantInt::ConstantInt(bool V)
- : Constant(Type::Int1Ty, ConstantIntVal, 0, 0), Val(uint64_t(V)) {
+namespace {
+ struct DenseMapAPIntKeyInfo {
+ struct KeyTy {
+ APInt val;
+ const Type* type;
+ KeyTy(const APInt& V, const Type* Ty) : val(V), type(Ty) {}
+ KeyTy(const KeyTy& that) : val(that.val), type(that.type) {}
+ bool operator==(const KeyTy& that) const {
+ return type == that.type && this->val == that.val;
+ }
+ bool operator!=(const KeyTy& that) const {
+ return !this->operator==(that);
+ }
+ };
+ static inline KeyTy getEmptyKey() { return KeyTy(APInt(1,0), 0); }
+ static inline KeyTy getTombstoneKey() { return KeyTy(APInt(1,1), 0); }
+ static unsigned getHashValue(const KeyTy &Key) {
+ return DenseMapKeyInfo<void*>::getHashValue(Key.type) ^
+ Key.val.getHashValue();
+ }
+ static bool isPod() { return true; }
+ };
+}
+
+
+typedef DenseMap<DenseMapAPIntKeyInfo::KeyTy, ConstantInt*,
+ DenseMapAPIntKeyInfo> IntMapTy;
+static ManagedStatic<IntMapTy> IntConstants;
+
+ConstantInt *ConstantInt::get(const Type *Ty, uint64_t V, bool isSigned) {
+ const IntegerType *ITy = cast<IntegerType>(Ty);
+ return get(APInt(ITy->getBitWidth(), V, isSigned));
}
-ConstantInt::ConstantInt(const Type *Ty, uint64_t V)
- : Constant(Ty, ConstantIntVal, 0, 0), Val(Ty == Type::Int1Ty ? bool(V) : V) {
+// Get a ConstantInt from an APInt. Note that the value stored in the DenseMap
+// as the key, is a DensMapAPIntKeyInfo::KeyTy which has provided the
+// operator== and operator!= to ensure that the DenseMap doesn't attempt to
+// compare APInt's of different widths, which would violate an APInt class
+// invariant which generates an assertion.
+ConstantInt *ConstantInt::get(const APInt& V) {
+ // Get the corresponding integer type for the bit width of the value.
+ const IntegerType *ITy = IntegerType::get(V.getBitWidth());
+ // get an existing value or the insertion position
+ DenseMapAPIntKeyInfo::KeyTy Key(V, ITy);
+ ConstantInt *&Slot = (*IntConstants)[Key];
+ // if it exists, return it.
+ if (Slot)
+ return Slot;
+ // otherwise create a new one, insert it, and return it.
+ return Slot = new ConstantInt(ITy, V);
}
+//===----------------------------------------------------------------------===//
+// ConstantFP
+//===----------------------------------------------------------------------===//
+
+
ConstantFP::ConstantFP(const Type *Ty, double V)
: Constant(Ty, ConstantFPVal, 0, 0) {
- assert(isValueValidForType(Ty, V) && "Value too large for type!");
Val = V;
}
+bool ConstantFP::isNullValue() const {
+ return DoubleToBits(Val) == 0;
+}
+
+bool ConstantFP::isExactlyValue(double V) const {
+ return DoubleToBits(V) == DoubleToBits(Val);
+}
+
+
+namespace {
+ struct DenseMapInt64KeyInfo {
+ typedef std::pair<uint64_t, const Type*> KeyTy;
+ static inline KeyTy getEmptyKey() { return KeyTy(0, 0); }
+ static inline KeyTy getTombstoneKey() { return KeyTy(1, 0); }
+ static unsigned getHashValue(const KeyTy &Key) {
+ return DenseMapKeyInfo<void*>::getHashValue(Key.second) ^ Key.first;
+ }
+ static bool isPod() { return true; }
+ };
+ struct DenseMapInt32KeyInfo {
+ typedef std::pair<uint32_t, const Type*> KeyTy;
+ static inline KeyTy getEmptyKey() { return KeyTy(0, 0); }
+ static inline KeyTy getTombstoneKey() { return KeyTy(1, 0); }
+ static unsigned getHashValue(const KeyTy &Key) {
+ return DenseMapKeyInfo<void*>::getHashValue(Key.second) ^ Key.first;
+ }
+ static bool isPod() { return true; }
+ };
+}
+
+//---- ConstantFP::get() implementation...
+//
+typedef DenseMap<DenseMapInt32KeyInfo::KeyTy, ConstantFP*,
+ DenseMapInt32KeyInfo> FloatMapTy;
+typedef DenseMap<DenseMapInt64KeyInfo::KeyTy, ConstantFP*,
+ DenseMapInt64KeyInfo> DoubleMapTy;
+
+static ManagedStatic<FloatMapTy> FloatConstants;
+static ManagedStatic<DoubleMapTy> DoubleConstants;
+
+ConstantFP *ConstantFP::get(const Type *Ty, double V) {
+ if (Ty == Type::FloatTy) {
+ uint32_t IntVal = FloatToBits((float)V);
+
+ ConstantFP *&Slot = (*FloatConstants)[std::make_pair(IntVal, Ty)];
+ if (Slot) return Slot;
+ return Slot = new ConstantFP(Ty, (float)V);
+ } else if (Ty == Type::DoubleTy) {
+ uint64_t IntVal = DoubleToBits(V);
+ ConstantFP *&Slot = (*DoubleConstants)[std::make_pair(IntVal, Ty)];
+ if (Slot) return Slot;
+ return Slot = new ConstantFP(Ty, V);
+ // FIXME: Make long double constants work.
+ } else if (Ty == Type::X86_FP80Ty ||
+ Ty == Type::PPC_FP128Ty || Ty == Type::FP128Ty) {
+ assert(0 && "Long double constants not handled yet.");
+ } else {
+ assert(0 && "Unknown FP Type!");
+ }
+}
+
+
+//===----------------------------------------------------------------------===//
+// ConstantXXX Classes
+//===----------------------------------------------------------------------===//
+
+
ConstantArray::ConstantArray(const ArrayType *T,
const std::vector<Constant*> &V)
: Constant(T, ConstantArrayVal, new Use[V.size()], V.size()) {
assert((C->getType() == T->getElementType() ||
(T->isAbstract() &&
C->getType()->getTypeID() == T->getElementType()->getTypeID())) &&
- "Initializer for packed element doesn't match packed element type!");
+ "Initializer for vector element doesn't match vector element type!");
OL->init(C, this);
}
}
Op2 = (OpNo == 2) ? Op : getOperand(2);
return ConstantExpr::getShuffleVector(Op0, Op1, Op2);
case Instruction::GetElementPtr: {
- std::vector<Constant*> Ops;
+ SmallVector<Constant*, 8> Ops;
+ Ops.resize(getNumOperands());
for (unsigned i = 1, e = getNumOperands(); i != e; ++i)
- Ops.push_back(getOperand(i));
+ Ops[i] = getOperand(i);
if (OpNo == 0)
- return ConstantExpr::getGetElementPtr(Op, Ops);
+ return ConstantExpr::getGetElementPtr(Op, &Ops[0], Ops.size());
Ops[OpNo-1] = Op;
- return ConstantExpr::getGetElementPtr(getOperand(0), Ops);
+ return ConstantExpr::getGetElementPtr(getOperand(0), &Ops[0], Ops.size());
}
default:
assert(getNumOperands() == 2 && "Must be binary operator?");
return ConstantExpr::getExtractElement(Ops[0], Ops[1]);
case Instruction::ShuffleVector:
return ConstantExpr::getShuffleVector(Ops[0], Ops[1], Ops[2]);
- case Instruction::GetElementPtr: {
- std::vector<Constant*> ActualOps(Ops.begin()+1, Ops.end());
- return ConstantExpr::getGetElementPtr(Ops[0], ActualOps);
- }
+ case Instruction::GetElementPtr:
+ return ConstantExpr::getGetElementPtr(Ops[0], &Ops[1], Ops.size()-1);
case Instruction::ICmp:
case Instruction::FCmp:
return ConstantExpr::getCompare(getPredicate(), Ops[0], Ops[1]);
default:
return false; // These can't be represented as floating point!
- // TODO: Figure out how to test if a double can be cast to a float!
+ // TODO: Figure out how to test if we can use a shorter type instead!
case Type::FloatTyID:
case Type::DoubleTyID:
- return true; // This is the largest type...
+ case Type::X86_FP80TyID:
+ case Type::PPC_FP128TyID:
+ case Type::FP128TyID:
+ return true;
}
}
///
AbstractTypeMapTy AbstractTypeMap;
- private:
- void clear(std::vector<Constant *> &Constants) {
- for(typename MapTy::iterator I = Map.begin(); I != Map.end(); ++I)
- Constants.push_back(I->second);
- Map.clear();
- AbstractTypeMap.clear();
- InverseMap.clear();
- }
-
public:
typename MapTy::iterator map_end() { return Map.end(); }
}
-//---- ConstantInt::get() implementations...
-//
-static ManagedStatic<ValueMap<uint64_t, Type, ConstantInt> > IntConstants;
-
-// Get a ConstantInt from an int64_t. Note here that we canoncialize the value
-// to a uint64_t value that has been zero extended down to the size of the
-// integer type of the ConstantInt. This allows the getZExtValue method to
-// just return the stored value while getSExtValue has to convert back to sign
-// extended. getZExtValue is more common in LLVM than getSExtValue().
-ConstantInt *ConstantInt::get(const Type *Ty, int64_t V) {
- if (Ty == Type::Int1Ty)
- if (V & 1)
- return getTrue();
- else
- return getFalse();
- return IntConstants->getOrCreate(Ty, V & cast<IntegerType>(Ty)->getBitMask());
-}
-
-//---- ConstantFP::get() implementation...
-//
-namespace llvm {
- template<>
- struct ConstantCreator<ConstantFP, Type, uint64_t> {
- static ConstantFP *create(const Type *Ty, uint64_t V) {
- assert(Ty == Type::DoubleTy);
- return new ConstantFP(Ty, BitsToDouble(V));
- }
- };
- template<>
- struct ConstantCreator<ConstantFP, Type, uint32_t> {
- static ConstantFP *create(const Type *Ty, uint32_t V) {
- assert(Ty == Type::FloatTy);
- return new ConstantFP(Ty, BitsToFloat(V));
- }
- };
-}
-
-static ManagedStatic<ValueMap<uint64_t, Type, ConstantFP> > DoubleConstants;
-static ManagedStatic<ValueMap<uint32_t, Type, ConstantFP> > FloatConstants;
-
-bool ConstantFP::isNullValue() const {
- return DoubleToBits(Val) == 0;
-}
-
-bool ConstantFP::isExactlyValue(double V) const {
- return DoubleToBits(V) == DoubleToBits(Val);
-}
-
-
-ConstantFP *ConstantFP::get(const Type *Ty, double V) {
- if (Ty == Type::FloatTy) {
- // Force the value through memory to normalize it.
- return FloatConstants->getOrCreate(Ty, FloatToBits(V));
- } else {
- assert(Ty == Type::DoubleTy);
- return DoubleConstants->getOrCreate(Ty, DoubleToBits(V));
- }
-}
//---- ConstantAggregateZero::get() implementation...
//
}
static ManagedStatic<ValueMap<std::vector<Constant*>, VectorType,
- ConstantVector> > PackedConstants;
+ ConstantVector> > VectorConstants;
Constant *ConstantVector::get(const VectorType *Ty,
const std::vector<Constant*> &V) {
- // If this is an all-zero packed, return a ConstantAggregateZero object
+ // If this is an all-zero vector, return a ConstantAggregateZero object
if (!V.empty()) {
Constant *C = V[0];
if (!C->isNullValue())
- return PackedConstants->getOrCreate(Ty, V);
+ return VectorConstants->getOrCreate(Ty, V);
for (unsigned i = 1, e = V.size(); i != e; ++i)
if (V[i] != C)
- return PackedConstants->getOrCreate(Ty, V);
+ return VectorConstants->getOrCreate(Ty, V);
}
return ConstantAggregateZero::get(Ty);
}
// destroyConstant - Remove the constant from the constant table...
//
void ConstantVector::destroyConstant() {
- PackedConstants->remove(this);
+ VectorConstants->remove(this);
destroyConstantImpl();
}
-/// This function will return true iff every element in this packed constant
+/// This function will return true iff every element in this vector constant
/// is set to all ones.
/// @returns true iff this constant's emements are all set to all ones.
/// @brief Determine if the value is all ones.
Constant *ConstantExpr::getSizeOf(const Type *Ty) {
// sizeof is implemented as: (ulong) gep (Ty*)null, 1
- return getCast(Instruction::PtrToInt, getGetElementPtr(getNullValue(
- PointerType::get(Ty)), std::vector<Constant*>(1,
- ConstantInt::get(Type::Int32Ty, 1))), Type::Int64Ty);
-}
-
-Constant *ConstantExpr::getPtrPtrFromArrayPtr(Constant *C) {
- // pointer from array is implemented as: getelementptr arr ptr, 0, 0
- static std::vector<Constant*> Indices(2, ConstantInt::get(Type::Int32Ty, 0));
-
- return ConstantExpr::getGetElementPtr(C, Indices);
+ Constant *GEPIdx = ConstantInt::get(Type::Int32Ty, 1);
+ Constant *GEP =
+ getGetElementPtr(getNullValue(PointerType::get(Ty)), &GEPIdx, 1);
+ return getCast(Instruction::PtrToInt, GEP, Type::Int64Ty);
}
Constant *ConstantExpr::getTy(const Type *ReqTy, unsigned Opcode,
Constant *ConstantExpr::getExtractElement(Constant *Val, Constant *Idx) {
assert(isa<VectorType>(Val->getType()) &&
- "Tried to create extractelement operation on non-packed type!");
+ "Tried to create extractelement operation on non-vector type!");
assert(Idx->getType() == Type::Int32Ty &&
"Extractelement index must be i32 type!");
return getExtractElementTy(cast<VectorType>(Val->getType())->getElementType(),
Constant *ConstantExpr::getInsertElement(Constant *Val, Constant *Elt,
Constant *Idx) {
assert(isa<VectorType>(Val->getType()) &&
- "Tried to create insertelement operation on non-packed type!");
+ "Tried to create insertelement operation on non-vector type!");
assert(Elt->getType() == cast<VectorType>(Val->getType())->getElementType()
&& "Insertelement types must match!");
assert(Idx->getType() == Type::Int32Ty &&
Constant *Replacement = 0;
if (getOpcode() == Instruction::GetElementPtr) {
- std::vector<Constant*> Indices;
+ SmallVector<Constant*, 8> Indices;
Constant *Pointer = getOperand(0);
Indices.reserve(getNumOperands()-1);
if (Pointer == From) Pointer = To;
if (Val == From) Val = To;
Indices.push_back(Val);
}
- Replacement = ConstantExpr::getGetElementPtr(Pointer, Indices);
+ Replacement = ConstantExpr::getGetElementPtr(Pointer,
+ &Indices[0], Indices.size());
} else if (isCast()) {
assert(getOperand(0) == From && "Cast only has one use!");
Replacement = ConstantExpr::getCast(getOpcode(), To, getType());
projects / oota-llvm.git / blobdiff