//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
#include "llvm/Constant.h"
#include "llvm/Type.h"
-#include "Support/DataTypes.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.
};
-//===---------------------------------------------------------------------------
+//===----------------------------------------------------------------------===//
/// ConstantBool - Boolean Values
///
class ConstantBool : public ConstantIntegral {
};
-//===---------------------------------------------------------------------------
+//===----------------------------------------------------------------------===//
/// ConstantInt - Superclass of ConstantSInt & ConstantUInt, to make dealing
/// with integral constants easier.
///
};
-//===---------------------------------------------------------------------------
+//===----------------------------------------------------------------------===//
/// ConstantSInt - Signed Integer Values [sbyte, short, int, long]
///
class ConstantSInt : public ConstantInt {
}
};
-//===---------------------------------------------------------------------------
+//===----------------------------------------------------------------------===//
/// ConstantUInt - Unsigned Integer Values [ubyte, ushort, uint, ulong]
///
class ConstantUInt : public ConstantInt {
};
-//===---------------------------------------------------------------------------
+//===----------------------------------------------------------------------===//
/// ConstantFP - Floating Point Values [float, double]
///
class ConstantFP : public Constant {
}
};
-//===---------------------------------------------------------------------------
+//===----------------------------------------------------------------------===//
/// ConstantAggregateZero - All zero aggregate value
///
class ConstantAggregateZero : public Constant {
};
-//===---------------------------------------------------------------------------
+//===----------------------------------------------------------------------===//
/// 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. This always returns false because zero arrays are always
/// created as ConstantAggregateZero objects.
};
-//===---------------------------------------------------------------------------
+//===----------------------------------------------------------------------===//
// ConstantStruct - Constant Struct Declarations
//
class ConstantStruct : public Constant {
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. This always returns false because zero structs are always
/// created as ConstantAggregateZero objects.
}
};
-//===---------------------------------------------------------------------------
+//===----------------------------------------------------------------------===//
+/// ConstantPacked - Constant Packed Declarations
+///
+class ConstantPacked : public Constant {
+ friend struct ConstantCreator<ConstantPacked, PackedType,
+ std::vector<Constant*> >;
+ ConstantPacked(const ConstantPacked &); // DO NOT IMPLEMENT
+protected:
+ ConstantPacked(const PackedType *T, const std::vector<Constant*> &Val);
+public:
+ /// get() - Static factory methods - Return objects of the specified value
+ 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. 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 ConstantPacked *) { return true; }
+ static bool classof(const Value *V) {
+ return V->getValueType() == SimpleConstantVal &&
+ V->getType()->getTypeID() == Type::PackedTyID;
+ }
+};
+
+//===----------------------------------------------------------------------===//
/// ConstantPointerNull - a constant pointer value that points to null
///
class ConstantPointerNull : public Constant {
virtual void destroyConstant();
+ /// 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 ConstantPointerNull *) { return true; }
static bool classof(const Value *V) {
};
-// 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,
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
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);
/// ConstantExpr::get* - Return some common constants without having to
/// specify the full Instruction::OPCODE identifier.
static Constant *getUShr(Constant *C1, Constant *C2); // unsigned shr
static Constant *getSShr(Constant *C1, Constant *C2); // signed shr
- /// Getelementptr form...
+ /// 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.
}
};
+
+//===----------------------------------------------------------------------===//
+/// 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;
+ }
+};
+
} // End llvm namespace
#endif
projects / oota-llvm.git / blobdiff