X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FConstants.h;h=cce4d49d1fbaf7fea9c330d1a7fb456c9fc2395e;hb=a51139f446bc9083096885f5f8956db6c8c77981;hp=bf88ef78f8af2913768dcd3f2326240403174f38;hpb=5133a5cf2ee42b5a4d4c7af2d90b41af769cc307;p=oota-llvm.git diff --git a/include/llvm/Constants.h b/include/llvm/Constants.h index bf88ef78f8a..cce4d49d1fb 100644 --- a/include/llvm/Constants.h +++ b/include/llvm/Constants.h @@ -1,7 +1,19 @@ //===-- llvm/Constants.h - Constant class subclass definitions --*- C++ -*-===// // +// 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 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. // //===----------------------------------------------------------------------===// @@ -9,28 +21,53 @@ #define LLVM_CONSTANTS_H #include "llvm/Constant.h" -#include "Support/DataTypes.h" +#include "llvm/Type.h" + +namespace llvm { class ArrayType; class StructType; class PointerType; +class PackedType; template struct ConstantCreator; template 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, ValueTy VT, 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; } + + /// getZExtValue - Return the constant zero extended as appropriate for this + /// type. + inline uint64_t getZExtValue() const { + unsigned Size = getType()->getPrimitiveSizeInBits(); + return Val.Unsigned & (~uint64_t(0UL) >> (64-Size)); + } + + /// getSExtValue - Return the constant sign extended as appropriate for this + /// type. + inline int64_t getSExtValue() const { + unsigned Size = getType()->getPrimitiveSizeInBits(); + return (Val.Signed << (64-Size)) >> (64-Size); + } + /// isNullValue - Return true if this is the value that would be returned by /// getNullValue. /// @@ -59,18 +96,18 @@ public: /// 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(V) && classof(cast(V)); + static bool classof(const Value *V) { + return V->getValueType() == ConstantBoolVal || + V->getValueType() == ConstantSIntVal || + V->getValueType() == ConstantUIntVal; } }; -//===--------------------------------------------------------------------------- +//===----------------------------------------------------------------------===// /// ConstantBool - Boolean Values /// class ConstantBool : public ConstantIntegral { - bool Val; ConstantBool(bool V); public: static ConstantBool *True, *False; // The True & False values @@ -84,7 +121,7 @@ public: /// getValue - return the boolean value of this constant. /// - inline bool getValue() const { return Val; } + inline bool getValue() const { return static_cast(getRawValue()); } /// isNullValue - Return true if this is the value that would be returned by /// getNullValue. @@ -96,27 +133,20 @@ public: /// 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(V) && classof(cast(V)); + static bool classof(const Value *V) { + return V->getValueType() == ConstantBoolVal; } }; -//===--------------------------------------------------------------------------- +//===----------------------------------------------------------------------===// /// 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); + ConstantInt(const Type *Ty, ValueTy VT, uint64_t V); public: /// equalsInt - Provide a helper method that can be used to determine if the /// constant contained within is equal to a constant. This only works for @@ -125,7 +155,7 @@ 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; } @@ -134,11 +164,6 @@ public: /// 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; } @@ -147,14 +172,14 @@ public: /// 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(V) && classof(cast(V)); + static bool classof(const Value *V) { + return V->getValueType() == ConstantSIntVal || + V->getValueType() == ConstantUIntVal; } }; -//===--------------------------------------------------------------------------- +//===----------------------------------------------------------------------===// /// ConstantSInt - Signed Integer Values [sbyte, short, int, long] /// class ConstantSInt : public ConstantInt { @@ -201,13 +226,12 @@ public: /// 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(V) && classof(cast(V)); + static bool classof(const Value *V) { + return V->getValueType() == ConstantSIntVal; } }; -//===--------------------------------------------------------------------------- +//===----------------------------------------------------------------------===// /// ConstantUInt - Unsigned Integer Values [ubyte, ushort, uint, ulong] /// class ConstantUInt : public ConstantInt { @@ -237,19 +261,19 @@ public: /// 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(V) && classof(cast(V)); + static bool classof(const Value *V) { + return V->getValueType() == ConstantUIntVal; } }; -//===--------------------------------------------------------------------------- +//===----------------------------------------------------------------------===// /// ConstantFP - Floating Point Values [float, double] /// class ConstantFP : public Constant { double Val; - friend struct ConstantCreator; + friend struct ConstantCreator; + friend struct ConstantCreator; ConstantFP(const ConstantFP &); // DO NOT IMPLEMENT protected: ConstantFP(const Type *Ty, double V); @@ -262,19 +286,53 @@ public: inline double getValue() const { return Val; } /// isNullValue - Return true if this is the value that would be returned by - /// getNullValue. - virtual bool isNullValue() const { return Val == 0; } + /// getNullValue. Don't depend on == for doubles to tell us it's zero, it + /// considers -0.0 to be null as well as 0.0. :( + virtual bool isNullValue() const; + + /// isExactlyValue - We don't rely on operator== working on double values, as + /// it returns true for things that are clearly not equal, like -0.0 and 0.0. + /// As such, this method can be used to do an exact bit-for-bit comparison of + /// two floating point values. + bool isExactlyValue(double V) const; /// 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(V) && classof(cast(V)); + static bool classof(const Value *V) { + return V->getValueType() == ConstantFPVal; + } +}; + +//===----------------------------------------------------------------------===// +/// ConstantAggregateZero - All zero aggregate value +/// +class ConstantAggregateZero : public Constant { + friend struct ConstantCreator; + ConstantAggregateZero(const ConstantAggregateZero &); // DO NOT IMPLEMENT +protected: + ConstantAggregateZero(const Type *Ty) + : Constant(Ty, ConstantAggregateZeroVal, 0, 0) {} +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(); + + /// 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 { @@ -283,53 +341,52 @@ class ConstantArray : public Constant { ConstantArray(const ConstantArray &); // DO NOT IMPLEMENT protected: ConstantArray(const ArrayType *T, const std::vector &Val); + ~ConstantArray(); public: /// get() - Static factory methods - Return objects of the specified value - static ConstantArray *get(const ArrayType *T, const std::vector &); - static ConstantArray *get(const std::string &Initializer); - + static Constant *get(const ArrayType *T, const std::vector &); + + /// This method constructs a ConstantArray and initializes it with a text + /// string. The default behavior (AddNull==true) causes a null terminator to + /// be placed at the end of the array. This effectively increases the length + /// of the array by one (you've been warned). However, in some situations + /// this is not desired so if AddNull==false then the string is copied without + /// null termination. + static Constant *get(const std::string &Initializer, bool AddNull = true); + /// getType - Specialize the getType() method to always return an ArrayType, /// which reduces the amount of casting needed in parts of the compiler. /// inline const ArrayType *getType() const { - return (ArrayType*)Value::getType(); + return reinterpret_cast(Value::getType()); } - /// getAsString - If the sub-element type of this array is either sbyte or - /// ubyte, then this method converts the array to an std::string and returns - /// it. Otherwise, it asserts out. + /// isString - This method returns true if the array is an array of sbyte or + /// ubyte, and if the elements of the array are all ConstantInt's. + bool isString() const; + + /// getAsString - If this array is isString(), then this method converts the + /// array to an std::string and returns it. Otherwise, it asserts out. /// std::string getAsString() const; - /// getValues - Return a vector of the component constants that make up this - /// array. - inline const std::vector &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! - for (unsigned i = 0, e = getNumOperands(); i != e; ++i) - if (!cast(getOperand(i))->isNullValue()) - 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, - bool DisableChecking = false); + virtual void replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U); /// 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(V) && classof(cast(V)); + static bool classof(const Value *V) { + return V->getValueType() == ConstantArrayVal; } }; -//===--------------------------------------------------------------------------- +//===----------------------------------------------------------------------===// // ConstantStruct - Constant Struct Declarations // class ConstantStruct : public Constant { @@ -338,78 +395,83 @@ class ConstantStruct : public Constant { ConstantStruct(const ConstantStruct &); // DO NOT IMPLEMENT protected: ConstantStruct(const StructType *T, const std::vector &Val); + ~ConstantStruct(); public: /// get() - Static factory methods - Return objects of the specified value - static ConstantStruct *get(const StructType *T, - const std::vector &V); + /// + static Constant *get(const StructType *T, const std::vector &V); + static Constant *get(const std::vector &V); /// getType() specialization - Reduce amount of casting... + /// inline const StructType *getType() const { - return (StructType*)Value::getType(); + return reinterpret_cast(Value::getType()); } - /// getValues - Return a vector of the component constants that make up this - /// structure. - inline const std::vector &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(getOperand(i))->isNullValue()) - return false; - return true; + return false; } virtual void destroyConstant(); - virtual void replaceUsesOfWithOnConstant(Value *From, Value *To, - bool DisableChecking = false); - + virtual void replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U); + /// 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(V) && classof(cast(V)); + static bool classof(const Value *V) { + return V->getValueType() == ConstantStructVal; } }; -//===--------------------------------------------------------------------------- -/// ConstantPointer - Constant Pointer Declarations -/// -/// The ConstantPointer class represents a null pointer of a specific type. For -/// a more specific/useful instance, a subclass of ConstantPointer should be -/// used. +//===----------------------------------------------------------------------===// +/// ConstantPacked - Constant Packed Declarations /// -class ConstantPointer : public Constant { - ConstantPointer(const ConstantPointer &); // DO NOT IMPLEMENT +class ConstantPacked : public Constant { + friend struct ConstantCreator >; + ConstantPacked(const ConstantPacked &); // DO NOT IMPLEMENT protected: - inline ConstantPointer(const PointerType *T) : Constant((const Type*)T) {} + ConstantPacked(const PackedType *T, const std::vector &Val); + ~ConstantPacked(); public: - inline const PointerType *getType() const { - return (PointerType*)Value::getType(); + /// get() - Static factory methods - Return objects of the specified value + static Constant *get(const PackedType *T, const std::vector &); + static Constant *get(const std::vector &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(Value::getType()); } /// isNullValue - Return true if this is the value that would be returned by - /// getNullValue. + /// 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, Use *U); + /// Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const ConstantPointer *) { return true; } - static bool classof(const Constant *CPV); // defined in Constants.cpp - static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); + static inline bool classof(const ConstantPacked *) { return true; } + static bool classof(const Value *V) { + return V->getValueType() == ConstantPackedVal; } }; +//===----------------------------------------------------------------------===// /// ConstantPointerNull - a constant pointer value that points to null /// -class ConstantPointerNull : public ConstantPointer { +class ConstantPointerNull : public Constant { friend struct ConstantCreator; ConstantPointerNull(const ConstantPointerNull &); // DO NOT IMPLEMENT protected: - ConstantPointerNull(const PointerType *T) : ConstantPointer(T) {} + ConstantPointerNull(const PointerType *T) + : Constant(reinterpret_cast(T), + Value::ConstantPointerNullVal, 0, 0) {} public: @@ -422,79 +484,38 @@ public: 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(Value::getType()); + } + /// Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const ConstantPointerNull *) { return true; } - static inline bool classof(const ConstantPointer *P) { - return (P->getNumOperands() == 0 && P->isNullValue()); - } - static inline bool classof(const Constant *CPV) { - return isa(CPV) && classof(cast(CPV)); - } - static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); + static bool classof(const Value *V) { + return V->getValueType() == ConstantPointerNullVal; } }; -/// ConstantPointerRef - a constant pointer value that is initialized to -/// point to a global value, which lies at a constant, fixed address. +/// ConstantExpr - a constant value that is initialized with an expression using +/// other constant values. /// -class ConstantPointerRef : public ConstantPointer { - friend class Module; // Modules maintain these references - ConstantPointerRef(const ConstantPointerRef &); // DNI! - -protected: - ConstantPointerRef(GlobalValue *GV); -public: - /// get() - Static factory methods - Return objects of the specified value - static ConstantPointerRef *get(GlobalValue *GV); - - const GlobalValue *getValue() const { - return cast(Operands[0].get()); - } - - GlobalValue *getValue() { - return cast(Operands[0].get()); - } - - 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 ConstantPointerRef *) { return true; } - static inline bool classof(const ConstantPointer *CPV) { - // check for a single operand (the target value) - return (CPV->getNumOperands() == 1); - } - static inline bool classof(const Constant *CPV) { - return isa(CPV) && classof(cast(CPV)); - } - static inline bool classof(const Value *V) { - return isa(V) && classof(cast(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. -// +/// This class uses the standard Instruction opcodes to define the various +/// constant expressions. The Opcode field for the ConstantExpr class is +/// maintained in the Value::SubclassData field. class ConstantExpr : public Constant { - unsigned iType; // Operation type (an Instruction opcode) friend struct ConstantCreator > >; friend struct ConvertConstantType; - + protected: - // Cast creation ctor - ConstantExpr(unsigned Opcode, Constant *C, const Type *Ty); - // Binary/Shift instruction creation ctor - ConstantExpr(unsigned Opcode, Constant *C1, Constant *C2); - // GEP instruction creation ctor - ConstantExpr(Constant *C, const std::vector &IdxList, - const Type *DestTy); + ConstantExpr(const Type *Ty, unsigned Opcode, Use *Ops, unsigned NumOps) + : Constant(Ty, ConstantExprVal, Ops, NumOps) { + // Operation type (an Instruction opcode) is stored as the SubclassData. + SubclassData = Opcode; + } // These private methods are used by the type resolution code to create // ConstantExprs in intermediate forms. @@ -502,70 +523,147 @@ protected: 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 &IdxList); - + const std::vector &IdxList); + static Constant *getExtractElementTy(const Type *Ty, Constant *Val, + Constant *Idx); + static Constant *getInsertElementTy(const Type *Ty, Constant *Val, + Constant *Elt, Constant *Idx); + static Constant *getShuffleVectorTy(const Type *Ty, Constant *V1, + Constant *V2, Constant *Mask); + public: // Static methods to construct a ConstantExpr of different kinds. Note that // these methods may return a object that is not an instance of the // ConstantExpr class, because they will attempt to fold the constant // expression into something simpler if possible. - + /// 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); - /// Binary constant expr - Use with binary operators... + /// Select constant expr /// - static Constant *get(unsigned Opcode, Constant *C1, Constant *C2) { - return getTy(C1->getType(), Opcode, C1, C2); + static Constant *getSelect(Constant *C, Constant *V1, Constant *V2) { + return getSelectTy(V1->getType(), C, V1, V2); } - /// getShift - Return a shift left or shift right constant expr + /// 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 *getShift(unsigned Opcode, Constant *C1, Constant *C2) { - return getShiftTy(C1->getType(), Opcode, C1, C2); - } + static Constant *getSizeOf(const Type *Ty); + + /// getPtrPtrFromArrayPtr constant expr - given a pointer to a constant array, + /// return a pointer to a pointer of the array element type. + static Constant *getPtrPtrFromArrayPtr(Constant *C); + + /// ConstantExpr::get - Return a binary or shift operator constant expression, + /// folding if possible. + /// + 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 is only accepted for convenience: + /// all elements must be Constant's. /// static Constant *getGetElementPtr(Constant *C, const std::vector &IdxList); + static Constant *getGetElementPtr(Constant *C, + const std::vector &IdxList); + + static Constant *getExtractElement(Constant *Vec, Constant *Idx); + static Constant *getInsertElement(Constant *Vec, Constant *Elt,Constant *Idx); + static Constant *getShuffleVector(Constant *V1, Constant *V2, Constant *Mask); /// isNullValue - Return true if this is the value that would be returned by /// getNullValue. virtual bool isNullValue() const { return false; } - + /// getOpcode - Return the opcode at the root of this constant expression - unsigned getOpcode() const { return iType; } + unsigned getOpcode() const { return SubclassData; } /// 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); - + virtual void replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U); + /// Override methods to provide more type information... - inline Constant *getOperand(unsigned i) { + inline Constant *getOperand(unsigned i) { return cast(User::getOperand(i)); } inline Constant *getOperand(unsigned i) const { return const_cast(cast(User::getOperand(i))); } - + /// 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(V) && classof(cast(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(const UndefValue &); // DO NOT IMPLEMENT +protected: + UndefValue(const Type *T) : Constant(T, UndefValueVal, 0, 0) {} +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