X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FConstants.h;h=f25d010f4ac45bdb0a1beaffa04488d5ceea6706;hb=aab3d88bc481fdc3081d2280dab4f7efd7e74a61;hp=d6529c7d5ffe1119ad7b1427fb018b52bd7d3148;hpb=d6d48c4e5b60aa4acc02c7a8700cb79949503e93;p=oota-llvm.git diff --git a/include/llvm/Constants.h b/include/llvm/Constants.h index d6529c7d5ff..f25d010f4ac 100644 --- a/include/llvm/Constants.h +++ b/include/llvm/Constants.h @@ -7,7 +7,8 @@ // //===----------------------------------------------------------------------===// // -/// @file This file contains the declarations for the subclasses of Constant, +/// @file +/// This file contains the declarations for the subclasses of Constant, /// which 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 @@ -22,8 +23,10 @@ #include "llvm/Constant.h" #include "llvm/Type.h" +#include "llvm/OperandTraits.h" #include "llvm/ADT/APInt.h" #include "llvm/ADT/APFloat.h" +#include "llvm/ADT/SmallVector.h" namespace llvm { @@ -73,7 +76,7 @@ public: } /// Return the constant as a 64-bit integer value after it has been sign - /// sign extended as appropriate for the type of this constant. Note that + /// extended as appropriate for the type of this constant. Note that /// this method can assert if the value does not fit in 64 bits. /// @deprecated /// @brief Return the sign extended value. @@ -193,9 +196,11 @@ public: return Val.getActiveBits() > 64 || Val.getZExtValue() >= Num; } - /// @returns the 64-bit value of this constant if its active bits number is - /// not greater than 64, otherwise, just return the given uint64_t number. - /// @brief Get the constant's value if possible. + /// getLimitedValue - If the value is smaller than the specified limit, + /// return it, otherwise return the limit value. This causes the value + /// to saturate to the limit. + /// @returns the min of the value of the constant and the specified value + /// @brief Get the constant's value with a saturation limit uint64_t getLimitedValue(uint64_t Limit = ~0ULL) const { return Val.getLimitedValue(Limit); } @@ -233,9 +238,6 @@ protected: public: /// get() - Static factory methods - Return objects of the specified value static ConstantFP *get(const APFloat &V); - static ConstantFP *get(const Type *Ty, const APFloat &V) { - return get(V); - } /// get() - This returns a constant fp for the specified value in the /// specified type. This should only be used for simple constant values like @@ -263,8 +265,12 @@ public: bool isExactlyValue(const APFloat& V) const; bool isExactlyValue(double V) const { + bool ignored; + // convert is not supported on this type + if (&Val.getSemantics() == &APFloat::PPCDoubleDouble) + return false; APFloat FV(V); - FV.convert(Val.getSemantics(), APFloat::rmNearestTiesToEven); + FV.convert(Val.getSemantics(), APFloat::rmNearestTiesToEven, &ignored); return isExactlyValue(FV); } /// Methods for support type inquiry through isa, cast, and dyn_cast: @@ -282,8 +288,8 @@ class ConstantAggregateZero : public Constant { void *operator new(size_t, unsigned); // DO NOT IMPLEMENT ConstantAggregateZero(const ConstantAggregateZero &); // DO NOT IMPLEMENT protected: - explicit ConstantAggregateZero(const Type *Ty) - : Constant(Ty, ConstantAggregateZeroVal, 0, 0) {} + explicit ConstantAggregateZero(const Type *ty) + : Constant(ty, ConstantAggregateZeroVal, 0, 0) {} protected: // allocate space for exactly zero operands void *operator new(size_t s) { @@ -292,7 +298,7 @@ protected: 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); + static ConstantAggregateZero *get(const Type *Ty); /// isNullValue - Return true if this is the value that would be returned by /// getNullValue. @@ -318,7 +324,6 @@ 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 Constant *get(const ArrayType *T, const std::vector &); @@ -336,6 +341,9 @@ public: /// null termination. static Constant *get(const std::string &Initializer, bool AddNull = true); + /// Transparently provide more efficient getOperand methods. + DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant); + /// getType - Specialize the getType() method to always return an ArrayType, /// which reduces the amount of casting needed in parts of the compiler. /// @@ -374,6 +382,11 @@ public: } }; +template <> +struct OperandTraits : VariadicOperandTraits<> { +}; + +DEFINE_TRANSPARENT_CASTED_OPERAND_ACCESSORS(ConstantArray, Constant) //===----------------------------------------------------------------------===// // ConstantStruct - Constant Struct Declarations @@ -384,7 +397,6 @@ 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 /// @@ -396,6 +408,9 @@ public: return get(std::vector(Vals, Vals+NumVals), Packed); } + /// Transparently provide more efficient getOperand methods. + DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant); + /// getType() specialization - Reduce amount of casting... /// inline const StructType *getType() const { @@ -419,6 +434,12 @@ public: } }; +template <> +struct OperandTraits : VariadicOperandTraits<> { +}; + +DEFINE_TRANSPARENT_CASTED_OPERAND_ACCESSORS(ConstantStruct, Constant) + //===----------------------------------------------------------------------===// /// ConstantVector - Constant Vector Declarations /// @@ -428,7 +449,6 @@ class ConstantVector : public Constant { ConstantVector(const ConstantVector &); // DO NOT IMPLEMENT protected: ConstantVector(const VectorType *T, const std::vector &Val); - ~ConstantVector(); public: /// get() - Static factory methods - Return objects of the specified value static Constant *get(const VectorType *T, const std::vector &); @@ -438,6 +458,9 @@ public: return get(std::vector(Vals, Vals+NumVals)); } + /// Transparently provide more efficient getOperand methods. + DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant); + /// getType - Specialize the getType() method to always return a VectorType, /// which reduces the amount of casting needed in parts of the compiler. /// @@ -475,6 +498,12 @@ public: } }; +template <> +struct OperandTraits : VariadicOperandTraits<> { +}; + +DEFINE_TRANSPARENT_CASTED_OPERAND_ACCESSORS(ConstantVector, Constant) + //===----------------------------------------------------------------------===// /// ConstantPointerNull - a constant pointer value that points to null /// @@ -529,8 +558,8 @@ class ConstantExpr : public Constant { friend struct ConvertConstantType; protected: - ConstantExpr(const Type *Ty, unsigned Opcode, Use *Ops, unsigned NumOps) - : Constant(Ty, ConstantExprVal, Ops, NumOps) { + 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; } @@ -539,7 +568,7 @@ protected: // ConstantExprs in intermediate forms. static Constant *getTy(const Type *Ty, unsigned Opcode, Constant *C1, Constant *C2); - static Constant *getCompareTy(unsigned short pred, Constant *C1, + static Constant *getCompareTy(unsigned short pred, Constant *C1, Constant *C2); static Constant *getSelectTy(const Type *Ty, Constant *C1, Constant *C2, Constant *C3); @@ -551,6 +580,11 @@ protected: Constant *Elt, Constant *Idx); static Constant *getShuffleVectorTy(const Type *Ty, Constant *V1, Constant *V2, Constant *Mask); + static Constant *getExtractValueTy(const Type *Ty, Constant *Agg, + const unsigned *Idxs, unsigned NumIdxs); + static Constant *getInsertValueTy(const Type *Ty, Constant *Agg, + Constant *Val, + const unsigned *Idxs, unsigned NumIdxs); public: // Static methods to construct a ConstantExpr of different kinds. Note that @@ -573,6 +607,9 @@ public: static Constant *getIntToPtr(Constant *C, const Type *Ty); static Constant *getBitCast (Constant *C, const Type *Ty); + /// Transparently provide more efficient getOperand methods. + DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant); + // @brief Convenience function for getting one of the casting operations // using a CastOps opcode. static Constant *getCast( @@ -624,6 +661,10 @@ public: /// @brief Return true if this is a compare constant expression bool isCompare() const; + /// @brief Return true if this is an insertvalue or extractvalue expression, + /// and the getIndices() method may be used. + bool hasIndices() const; + /// Select constant expr /// static Constant *getSelect(Constant *C, Constant *V1, Constant *V2) { @@ -640,7 +681,8 @@ public: /// static Constant *get(unsigned Opcode, Constant *C1, Constant *C2); - /// @brief Return an ICmp or FCmp comparison operator constant expression. + /// @brief Return an ICmp, FCmp, VICmp, or VFCmp comparison operator constant + /// expression. static Constant *getCompare(unsigned short pred, Constant *C1, Constant *C2); /// ConstantExpr::get* - Return some common constants without having to @@ -662,6 +704,8 @@ public: static Constant *getXor(Constant *C1, Constant *C2); static Constant *getICmp(unsigned short pred, Constant *LHS, Constant *RHS); static Constant *getFCmp(unsigned short pred, Constant *LHS, Constant *RHS); + static Constant *getVICmp(unsigned short pred, Constant *LHS, Constant *RHS); + static Constant *getVFCmp(unsigned short pred, Constant *LHS, Constant *RHS); static Constant *getShl(Constant *C1, Constant *C2); static Constant *getLShr(Constant *C1, Constant *C2); static Constant *getAShr(Constant *C1, Constant *C2); @@ -677,6 +721,10 @@ public: 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); + static Constant *getExtractValue(Constant *Agg, + const unsigned *IdxList, unsigned NumIdx); + static Constant *getInsertValue(Constant *Agg, Constant *Val, + const unsigned *IdxList, unsigned NumIdx); /// Floating point negation must be implemented with f(x) = -0.0 - x. This /// method returns the negative zero constant for floating point or vector @@ -694,6 +742,10 @@ public: /// not an ICMP or FCMP constant expression. unsigned getPredicate() const; + /// getIndices - Assert that this is an insertvalue or exactvalue + /// expression and return the list of indices. + const SmallVector &getIndices() const; + /// getOpcodeName - Return a string representation for an opcode. const char *getOpcodeName() const; @@ -704,20 +756,14 @@ public: /// getWithOperands - This returns the current constant expression with the /// operands replaced with the specified values. The specified operands must /// match count and type with the existing ones. - Constant *getWithOperands(const std::vector &Ops) const; + Constant *getWithOperands(const std::vector &Ops) const { + return getWithOperands(&Ops[0], (unsigned)Ops.size()); + } + Constant *getWithOperands(Constant* const *Ops, unsigned NumOps) const; virtual void destroyConstant(); virtual void replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U); - /// Override methods to provide more type information... - 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 Value *V) { @@ -725,6 +771,11 @@ public: } }; +template <> +struct OperandTraits : VariadicOperandTraits<1> { +}; + +DEFINE_TRANSPARENT_CASTED_OPERAND_ACCESSORS(ConstantExpr, Constant) //===----------------------------------------------------------------------===// /// UndefValue - 'undef' values are things that do not have specified contents.