//===----------------------------------------------------------------------===//
//
// This file contains the declarations for the subclasses of Constant, which
-// represent the different type of constant pool values
+// represent the different flavors of constant values that live in LLVM. Note
+// that Constants are immutable (once created they never change) and are fully
+// shared by structural equivalence. This means that two structurally
+// equivalent constants will always have the same address. Constant's are
+// created on demand as needed and never deleted: thus clients don't have to
+// worry about the lifetime of the objects.
//
//===----------------------------------------------------------------------===//
#define LLVM_CONSTANTS_H
#include "llvm/Constant.h"
-#include "Support/DataTypes.h"
+#include "llvm/Type.h"
+#include "llvm/Support/DataTypes.h"
namespace llvm {
class ArrayType;
class StructType;
class PointerType;
+class PackedType;
template<class ConstantClass, class TypeClass, class ValType>
struct ConstantCreator;
template<class ConstantClass, class TypeClass>
struct ConvertConstantType;
-
-//===---------------------------------------------------------------------------
+//===----------------------------------------------------------------------===//
/// ConstantIntegral - Shared superclass of boolean and integer constants.
///
/// This class just defines some common interfaces to be implemented.
///
class ConstantIntegral : public Constant {
protected:
- ConstantIntegral(const Type *Ty) : Constant(Ty) {}
+ union {
+ int64_t Signed;
+ uint64_t Unsigned;
+ } Val;
+ ConstantIntegral(const Type *Ty, uint64_t V);
public:
+ /// getRawValue - return the underlying value of this constant as a 64-bit
+ /// unsigned integer value.
+ ///
+ inline uint64_t getRawValue() const { return Val.Unsigned; }
+
/// isNullValue - Return true if this is the value that would be returned by
/// getNullValue.
///
/// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const ConstantIntegral *) { return true; }
- static bool classof(const Constant *CPV); // defined in Constants.cpp
- static inline bool classof(const Value *V) {
- return isa<Constant>(V) && classof(cast<Constant>(V));
+ static bool classof(const Value *V) {
+ return V->getValueType() == SimpleConstantVal &&
+ V->getType()->isIntegral();
}
};
-//===---------------------------------------------------------------------------
+//===----------------------------------------------------------------------===//
/// ConstantBool - Boolean Values
///
class ConstantBool : public ConstantIntegral {
- bool Val;
ConstantBool(bool V);
public:
static ConstantBool *True, *False; // The True & False values
/// getValue - return the boolean value of this constant.
///
- inline bool getValue() const { return Val; }
+ inline bool getValue() const { return static_cast<bool>(getRawValue()); }
/// isNullValue - Return true if this is the value that would be returned by
/// getNullValue.
/// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const ConstantBool *) { return true; }
- static bool classof(const Constant *CPV) {
- return (CPV == True) | (CPV == False);
- }
- static inline bool classof(const Value *V) {
- return isa<Constant>(V) && classof(cast<Constant>(V));
+ static bool classof(const Value *V) {
+ return (V == True) | (V == False);
}
};
-//===---------------------------------------------------------------------------
+//===----------------------------------------------------------------------===//
/// ConstantInt - Superclass of ConstantSInt & ConstantUInt, to make dealing
/// with integral constants easier.
///
class ConstantInt : public ConstantIntegral {
protected:
- union {
- int64_t Signed;
- uint64_t Unsigned;
- } Val;
ConstantInt(const ConstantInt &); // DO NOT IMPLEMENT
ConstantInt(const Type *Ty, uint64_t V);
public:
///
bool equalsInt(unsigned char V) const {
assert(V <= 127 &&
- "equals: Can only be used with very small positive constants!");
+ "equalsInt: Can only be used with very small positive constants!");
return Val.Unsigned == V;
}
///
static ConstantInt *get(const Type *Ty, unsigned char V);
- /// getRawValue - return the underlying value of this constant as a 64-bit
- /// unsigned integer value.
- ///
- inline uint64_t getRawValue() const { return Val.Unsigned; }
-
/// isNullValue - Return true if this is the value that would be returned by
/// getNullValue.
virtual bool isNullValue() const { return Val.Unsigned == 0; }
/// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const ConstantInt *) { return true; }
- static bool classof(const Constant *CPV); // defined in Constants.cpp
- static inline bool classof(const Value *V) {
- return isa<Constant>(V) && classof(cast<Constant>(V));
+ static bool classof(const Value *V) {
+ return V->getValueType() == SimpleConstantVal &&
+ V->getType()->isInteger();
}
};
-//===---------------------------------------------------------------------------
+//===----------------------------------------------------------------------===//
/// ConstantSInt - Signed Integer Values [sbyte, short, int, long]
///
class ConstantSInt : public ConstantInt {
/// Methods for support type inquiry through isa, cast, and dyn_cast:
///
static inline bool classof(const ConstantSInt *) { return true; }
- static bool classof(const Constant *CPV); // defined in Constants.cpp
- static inline bool classof(const Value *V) {
- return isa<Constant>(V) && classof(cast<Constant>(V));
+ static bool classof(const Value *V) {
+ return V->getValueType() == SimpleConstantVal &&
+ V->getType()->isSigned();
}
};
-//===---------------------------------------------------------------------------
+//===----------------------------------------------------------------------===//
/// ConstantUInt - Unsigned Integer Values [ubyte, ushort, uint, ulong]
///
class ConstantUInt : public ConstantInt {
/// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const ConstantUInt *) { return true; }
- static bool classof(const Constant *CPV); // defined in Constants.cpp
- static inline bool classof(const Value *V) {
- return isa<Constant>(V) && classof(cast<Constant>(V));
+ static bool classof(const Value *V) {
+ return V->getValueType() == SimpleConstantVal &&
+ V->getType()->isUnsigned();
}
};
-//===---------------------------------------------------------------------------
+//===----------------------------------------------------------------------===//
/// ConstantFP - Floating Point Values [float, double]
///
class ConstantFP : public Constant {
/// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const ConstantFP *) { return true; }
- static bool classof(const Constant *CPV); // defined in Constants.cpp
- static inline bool classof(const Value *V) {
- return isa<Constant>(V) && classof(cast<Constant>(V));
+ static bool classof(const Value *V) {
+ return V->getValueType() == SimpleConstantVal &&
+ V->getType()->isFloatingPoint();
}
};
+//===----------------------------------------------------------------------===//
+/// ConstantAggregateZero - All zero aggregate value
+///
+class ConstantAggregateZero : public Constant {
+ friend struct ConstantCreator<ConstantAggregateZero, Type, char>;
+ ConstantAggregateZero(const ConstantAggregateZero &); // DO NOT IMPLEMENT
+protected:
+ ConstantAggregateZero(const Type *Ty)
+ : Constant(Ty, ConstantAggregateZeroVal) {}
+public:
+ /// get() - static factory method for creating a null aggregate. It is
+ /// illegal to call this method with a non-aggregate type.
+ static Constant *get(const Type *Ty);
-//===---------------------------------------------------------------------------
+ /// isNullValue - Return true if this is the value that would be returned by
+ /// getNullValue.
+ virtual bool isNullValue() const { return true; }
+
+ virtual void destroyConstant();
+ virtual void replaceUsesOfWithOnConstant(Value *From, Value *To,
+ bool DisableChecking = false);
+
+ /// Methods for support type inquiry through isa, cast, and dyn_cast:
+ ///
+ static bool classof(const ConstantAggregateZero *) { return true; }
+ static bool classof(const Value *V) {
+ return V->getValueType() == ConstantAggregateZeroVal;
+ }
+};
+
+
+//===----------------------------------------------------------------------===//
/// ConstantArray - Constant Array Declarations
///
class ConstantArray : public Constant {
///
std::string getAsString() const;
- /// getValues - Return a vector of the component constants that make up this
- /// array.
- inline const std::vector<Use> &getValues() const { return Operands; }
-
/// isNullValue - Return true if this is the value that would be returned by
- /// getNullValue.
- virtual bool isNullValue() const {
- // FIXME: This should be made to be MUCH faster. Just check against well
- // known null value!
- if (getNumOperands()) {
- const Constant *First = cast<Constant>(getOperand(0));
- if (!First->isNullValue()) return false;
- for (unsigned i = 1, e = getNumOperands(); i != e; ++i)
- if (cast<Constant>(getOperand(i)) != First)
- return false;
- }
- return true;
- }
+ /// getNullValue. This always returns false because zero arrays are always
+ /// created as ConstantAggregateZero objects.
+ virtual bool isNullValue() const { return false; }
virtual void destroyConstant();
virtual void replaceUsesOfWithOnConstant(Value *From, Value *To,
/// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const ConstantArray *) { return true; }
- static bool classof(const Constant *CPV); // defined in Constants.cpp
- static inline bool classof(const Value *V) {
- return isa<Constant>(V) && classof(cast<Constant>(V));
+ static bool classof(const Value *V) {
+ return V->getValueType() == SimpleConstantVal &&
+ V->getType()->getTypeID() == Type::ArrayTyID;
}
};
-//===---------------------------------------------------------------------------
+//===----------------------------------------------------------------------===//
// ConstantStruct - Constant Struct Declarations
//
class ConstantStruct : public Constant {
ConstantStruct(const StructType *T, const std::vector<Constant*> &Val);
public:
/// get() - Static factory methods - Return objects of the specified value
+ ///
static Constant *get(const StructType *T, const std::vector<Constant*> &V);
+ static Constant *get(const std::vector<Constant*> &V);
/// getType() specialization - Reduce amount of casting...
+ ///
inline const StructType *getType() const {
return reinterpret_cast<const StructType*>(Value::getType());
}
- /// getValues - Return a vector of the component constants that make up this
- /// structure.
- inline const std::vector<Use> &getValues() const { return Operands; }
-
/// isNullValue - Return true if this is the value that would be returned by
- /// getNullValue.
+ /// getNullValue. This always returns false because zero structs are always
+ /// created as ConstantAggregateZero objects.
virtual bool isNullValue() const {
- // FIXME: This should be made to be MUCH faster. Just check against well
- // known null value!
- for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
- if (!cast<Constant>(getOperand(i))->isNullValue())
- return false;
- return true;
+ return false;
}
virtual void destroyConstant();
/// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const ConstantStruct *) { return true; }
- static bool classof(const Constant *CPV); // defined in Constants.cpp
- static inline bool classof(const Value *V) {
- return isa<Constant>(V) && classof(cast<Constant>(V));
+ static bool classof(const Value *V) {
+ return V->getValueType() == SimpleConstantVal &&
+ V->getType()->getTypeID() == Type::StructTyID;
}
};
-//===---------------------------------------------------------------------------
-/// ConstantPointerNull - a constant pointer value that points to null
+//===----------------------------------------------------------------------===//
+/// ConstantPacked - Constant Packed Declarations
///
-class ConstantPointerNull : public Constant {
- friend struct ConstantCreator<ConstantPointerNull, PointerType, char>;
- ConstantPointerNull(const ConstantPointerNull &); // DO NOT IMPLEMENT
+class ConstantPacked : public Constant {
+ friend struct ConstantCreator<ConstantPacked, PackedType,
+ std::vector<Constant*> >;
+ ConstantPacked(const ConstantPacked &); // DO NOT IMPLEMENT
protected:
- ConstantPointerNull(const PointerType *T)
- : Constant(reinterpret_cast<const Type*>(T)) {}
-
+ ConstantPacked(const PackedType *T, const std::vector<Constant*> &Val);
public:
-
/// get() - Static factory methods - Return objects of the specified value
- static ConstantPointerNull *get(const PointerType *T);
+ static Constant *get(const PackedType *T, const std::vector<Constant*> &);
+ static Constant *get(const std::vector<Constant*> &V);
+
+ /// getType - Specialize the getType() method to always return an PackedType,
+ /// which reduces the amount of casting needed in parts of the compiler.
+ ///
+ inline const PackedType *getType() const {
+ return reinterpret_cast<const PackedType*>(Value::getType());
+ }
/// isNullValue - Return true if this is the value that would be returned by
- /// getNullValue.
- virtual bool isNullValue() const { return true; }
+ /// getNullValue. This always returns false because zero arrays are always
+ /// created as ConstantAggregateZero objects.
+ virtual bool isNullValue() const { return false; }
virtual void destroyConstant();
+ virtual void replaceUsesOfWithOnConstant(Value *From, Value *To,
+ bool DisableChecking = false);
/// Methods for support type inquiry through isa, cast, and dyn_cast:
- static inline bool classof(const ConstantPointerNull *) { return true; }
- static bool classof(const Constant *CPV);
- static inline bool classof(const Value *V) {
- return isa<Constant>(V) && classof(cast<Constant>(V));
+ static inline bool classof(const ConstantPacked *) { return true; }
+ static bool classof(const Value *V) {
+ return V->getValueType() == SimpleConstantVal &&
+ V->getType()->getTypeID() == Type::PackedTyID;
}
};
-
-//===---------------------------------------------------------------------------
-/// ConstantPointerRef - a constant pointer value that is initialized to
-/// point to a global value, which lies at a constant, fixed address.
+//===----------------------------------------------------------------------===//
+/// ConstantPointerNull - a constant pointer value that points to null
///
-class ConstantPointerRef : public Constant {
- friend class Module; // Modules maintain these references
- ConstantPointerRef(const ConstantPointerRef &); // DNI!
-
+class ConstantPointerNull : public Constant {
+ friend struct ConstantCreator<ConstantPointerNull, PointerType, char>;
+ ConstantPointerNull(const ConstantPointerNull &); // DO NOT IMPLEMENT
protected:
- ConstantPointerRef(GlobalValue *GV);
-public:
- /// get() - Static factory methods - Return objects of the specified value
- static ConstantPointerRef *get(GlobalValue *GV);
+ ConstantPointerNull(const PointerType *T)
+ : Constant(reinterpret_cast<const Type*>(T)) {}
- const GlobalValue *getValue() const {
- return cast<GlobalValue>(Operands[0].get());
- }
+public:
- GlobalValue *getValue() {
- return cast<GlobalValue>(Operands[0].get());
- }
+ /// get() - Static factory methods - Return objects of the specified value
+ static ConstantPointerNull *get(const PointerType *T);
/// isNullValue - Return true if this is the value that would be returned by
/// getNullValue.
- virtual bool isNullValue() const { return false; }
+ virtual bool isNullValue() const { return true; }
virtual void destroyConstant();
- virtual void replaceUsesOfWithOnConstant(Value *From, Value *To,
- bool DisableChecking = false);
+
+ /// getType - Specialize the getType() method to always return an PointerType,
+ /// which reduces the amount of casting needed in parts of the compiler.
+ ///
+ inline const PointerType *getType() const {
+ return reinterpret_cast<const PointerType*>(Value::getType());
+ }
/// Methods for support type inquiry through isa, cast, and dyn_cast:
- static inline bool classof(const ConstantPointerRef *) { return true; }
- static bool classof(const Constant *CPV);
- static inline bool classof(const Value *V) {
- return isa<Constant>(V) && classof(cast<Constant>(V));
+ static inline bool classof(const ConstantPointerNull *) { return true; }
+ static bool classof(const Value *V) {
+ return V->getValueType() == SimpleConstantVal &&
+ isa<PointerType>(V->getType());
}
};
-// ConstantExpr - a constant value that is initialized with an expression using
-// other constant values. This is only used to represent values that cannot be
-// evaluated at compile-time (e.g., something derived from an address) because
-// it does not have a mechanism to store the actual value. Use the appropriate
-// Constant subclass above for known constants.
-//
+
+/// ConstantExpr - a constant value that is initialized with an expression using
+/// other constant values. This is only used to represent values that cannot be
+/// evaluated at compile-time (e.g., something derived from an address) because
+/// it does not have a mechanism to store the actual value. Use the appropriate
+/// Constant subclass above for known constants.
+///
class ConstantExpr : public Constant {
unsigned iType; // Operation type (an Instruction opcode)
friend struct ConstantCreator<ConstantExpr,Type,
ConstantExpr(unsigned Opcode, Constant *C, const Type *Ty);
// Binary/Shift instruction creation ctor
ConstantExpr(unsigned Opcode, Constant *C1, Constant *C2);
+ // Select instruction creation ctor
+ ConstantExpr(Constant *C, Constant *V1, Constant *V2);
// GEP instruction creation ctor
ConstantExpr(Constant *C, const std::vector<Constant*> &IdxList,
const Type *DestTy);
Constant *C1, Constant *C2);
static Constant *getShiftTy(const Type *Ty,
unsigned Opcode, Constant *C1, Constant *C2);
+ static Constant *getSelectTy(const Type *Ty,
+ Constant *C1, Constant *C2, Constant *C3);
static Constant *getGetElementPtrTy(const Type *Ty, Constant *C,
- const std::vector<Constant*> &IdxList);
+ const std::vector<Value*> &IdxList);
public:
// Static methods to construct a ConstantExpr of different kinds. Note that
/// Cast constant expr
///
static Constant *getCast(Constant *C, const Type *Ty);
+ static Constant *getSignExtend(Constant *C, const Type *Ty);
+ static Constant *getZeroExtend(Constant *C, const Type *Ty);
+
+ /// Select constant expr
+ ///
+ static Constant *getSelect(Constant *C, Constant *V1, Constant *V2) {
+ return getSelectTy(V1->getType(), C, V1, V2);
+ }
+
+ /// getSizeOf constant expr - computes the size of a type in a target
+ /// independent way (Note: the return type is ULong but the object is not
+ /// necessarily a ConstantUInt).
+ ///
+ static Constant *getSizeOf(const Type *Ty);
/// ConstantExpr::get - Return a binary or shift operator constant expression,
/// folding if possible.
///
- static Constant *get(unsigned Opcode, Constant *C1, Constant *C2) {
- return getTy(C1->getType(), Opcode, C1, C2);
- }
+ static Constant *get(unsigned Opcode, Constant *C1, Constant *C2);
- /// Getelementptr form...
+ /// ConstantExpr::get* - Return some common constants without having to
+ /// specify the full Instruction::OPCODE identifier.
+ ///
+ static Constant *getNeg(Constant *C);
+ static Constant *getNot(Constant *C);
+ static Constant *getAdd(Constant *C1, Constant *C2);
+ static Constant *getSub(Constant *C1, Constant *C2);
+ static Constant *getMul(Constant *C1, Constant *C2);
+ static Constant *getDiv(Constant *C1, Constant *C2);
+ static Constant *getRem(Constant *C1, Constant *C2);
+ static Constant *getAnd(Constant *C1, Constant *C2);
+ static Constant *getOr(Constant *C1, Constant *C2);
+ static Constant *getXor(Constant *C1, Constant *C2);
+ static Constant *getSetEQ(Constant *C1, Constant *C2);
+ static Constant *getSetNE(Constant *C1, Constant *C2);
+ static Constant *getSetLT(Constant *C1, Constant *C2);
+ static Constant *getSetGT(Constant *C1, Constant *C2);
+ static Constant *getSetLE(Constant *C1, Constant *C2);
+ static Constant *getSetGE(Constant *C1, Constant *C2);
+ static Constant *getShl(Constant *C1, Constant *C2);
+ static Constant *getShr(Constant *C1, Constant *C2);
+
+ static Constant *getUShr(Constant *C1, Constant *C2); // unsigned shr
+ static Constant *getSShr(Constant *C1, Constant *C2); // signed shr
+
+ /// Getelementptr form. std::vector<Value*> is only accepted for convenience:
+ /// all elements must be Constant's.
///
static Constant *getGetElementPtr(Constant *C,
const std::vector<Constant*> &IdxList);
+ static Constant *getGetElementPtr(Constant *C,
+ const std::vector<Value*> &IdxList);
/// isNullValue - Return true if this is the value that would be returned by
/// getNullValue.
/// getOpcodeName - Return a string representation for an opcode.
const char *getOpcodeName() const;
- /// isConstantExpr - Return true if this is a ConstantExpr
- virtual bool isConstantExpr() const { return true; }
-
virtual void destroyConstant();
virtual void replaceUsesOfWithOnConstant(Value *From, Value *To,
bool DisableChecking = false);
/// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const ConstantExpr *) { return true; }
- static inline bool classof(const Constant *CPV) {
- return CPV->isConstantExpr();
- }
static inline bool classof(const Value *V) {
- return isa<Constant>(V) && classof(cast<Constant>(V));
+ return V->getValueType() == ConstantExprVal;
+ }
+};
+
+
+//===----------------------------------------------------------------------===//
+/// UndefValue - 'undef' values are things that do not have specified contents.
+/// These are used for a variety of purposes, including global variable
+/// initializers and operands to instructions. 'undef' values can occur with
+/// any type.
+///
+class UndefValue : public Constant {
+ friend struct ConstantCreator<UndefValue, Type, char>;
+ UndefValue(const UndefValue &); // DO NOT IMPLEMENT
+protected:
+ UndefValue(const Type *T) : Constant(T, UndefValueVal) {}
+public:
+ /// get() - Static factory methods - Return an 'undef' object of the specified
+ /// type.
+ ///
+ static UndefValue *get(const Type *T);
+
+ /// isNullValue - Return true if this is the value that would be returned by
+ /// getNullValue.
+ virtual bool isNullValue() const { return false; }
+
+ virtual void destroyConstant();
+
+ /// Methods for support type inquiry through isa, cast, and dyn_cast:
+ static inline bool classof(const UndefValue *) { return true; }
+ static bool classof(const Value *V) {
+ return V->getValueType() == UndefValueVal;
}
};