X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FLLVMContext.h;h=134311e98afe750b2f1775dc262b80a3c80bf68c;hb=104cf9e02b0ed94d4173869a598af6c6972a8660;hp=f0c2200c7a3ddcc8141546d70032fe24eb1b4048;hpb=31895e73591d3c9ceae731a1274c8f56194b9616;p=oota-llvm.git diff --git a/include/llvm/LLVMContext.h b/include/llvm/LLVMContext.h index f0c2200c7a3..134311e98af 100644 --- a/include/llvm/LLVMContext.h +++ b/include/llvm/LLVMContext.h @@ -30,6 +30,9 @@ class ConstantAggregateZero; class ConstantArray; class ConstantFP; class ConstantVector; +class UndefValue; +class MDNode; +class MDString; class IntegerType; class PointerType; class StructType; @@ -41,6 +44,7 @@ class Type; class APInt; class APFloat; class Value; +class Use; /// This is an important class for using LLVM in a threaded context. It /// (opaquely) owns and manages the core "global" data of LLVM's core @@ -53,15 +57,50 @@ public: LLVMContext(); ~LLVMContext(); + // Constant accessors + Constant* getNullValue(const Type* Ty); + + /// @returns the value for an integer constant of the given type that has all + /// its bits set to true. + /// @brief Get the all ones value + Constant* getAllOnesValue(const Type* Ty); + + // UndefValue accessors + UndefValue* getUndef(const Type* Ty); + // ConstantInt accessors - ConstantInt* getConstantIntTrue(); - ConstantInt* getConstantIntFalse(); + ConstantInt* getTrue(); + ConstantInt* getFalse(); + + /// If Ty is a vector type, return a Constant with a splat of the given + /// value. Otherwise return a ConstantInt for the given value. + Constant* getConstantInt(const Type* Ty, uint64_t V, + bool isSigned = false); + + /// Return a ConstantInt with the specified integer value for the specified + /// type. If the type is wider than 64 bits, the value will be zero-extended + /// to fit the type, unless isSigned is true, in which case the value will + /// be interpreted as a 64-bit signed integer and sign-extended to fit + /// the type. + /// @brief Get a ConstantInt for a specific value. ConstantInt* getConstantInt(const IntegerType* Ty, uint64_t V, bool isSigned = false); + + /// Return a ConstantInt with the specified value for the specified type. The + /// value V will be canonicalized to a an unsigned APInt. Accessing it with + /// either getSExtValue() or getZExtValue() will yield a correctly sized and + /// signed value for the type Ty. + /// @brief Get a ConstantInt for a specific signed value. ConstantInt* getConstantIntSigned(const IntegerType* Ty, int64_t V); + Constant *getConstantIntSigned(const Type *Ty, int64_t V); + + /// Return a ConstantInt with the specified value and an implied Type. The + /// type is the integer type that corresponds to the bit width of the value. ConstantInt* getConstantInt(const APInt& V); + + /// If Ty is a vector type, return a Constant with a splat of the given + /// value. Otherwise return a ConstantInt for the given value. Constant* getConstantInt(const Type* Ty, const APInt& V); - ConstantInt* getAllOnesConstantInt(const Type* Ty); // ConstantPointerNull accessors ConstantPointerNull* getConstantPointerNull(const PointerType* T); @@ -82,8 +121,15 @@ public: const std::vector& V); Constant* getConstantArray(const ArrayType* T, Constant* const* Vals, unsigned NumVals); + + /// 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. Constant* getConstantArray(const std::string& Initializer, - bool AddNull = false); + bool AddNull = true); // ConstantExpr accessors Constant* getConstantExpr(unsigned Opcode, Constant* C1, Constant* C2); @@ -108,6 +154,11 @@ public: bool isSigned); Constant* getConstantExprFPCast(Constant* C, const Type* Ty); Constant* getConstantExprSelect(Constant* C, Constant* V1, Constant* V2); + + /// getAlignOf constant expr - computes the alignment of a type in a target + /// independent way (Note: the return type is an i32; Note: assumes that i8 + /// is byte aligned). + /// Constant* getConstantExprAlignOf(const Type* Ty); Constant* getConstantExprCompare(unsigned short pred, Constant* C1, Constant* C2); @@ -133,10 +184,6 @@ public: Constant* RHS); Constant* getConstantExprFCmp(unsigned short pred, Constant* LHS, Constant* RHS); - Constant* getConstantExprVICmp(unsigned short pred, Constant* LHS, - Constant* RHS); - Constant* getConstantExprVFCmp(unsigned short pred, Constant* LHS, - Constant* RHS); Constant* getConstantExprShl(Constant* C1, Constant* C2); Constant* getConstantExprLShr(Constant* C1, Constant* C2); Constant* getConstantExprAShr(Constant* C1, Constant* C2); @@ -154,10 +201,24 @@ public: Constant* getConstantExprInsertValue(Constant* Agg, Constant* Val, const unsigned* IdxList, unsigned NumIdx); + + /// getSizeOf constant expr - computes the size of a type in a target + /// independent way (Note: the return type is an i64). + /// + Constant* getConstantExprSizeOf(const Type* Ty); + + /// Floating point negation must be implemented with f(x) = -0.0 - x. This + /// method returns the negative zero constant for floating point or vector + /// floating point types; for all other types, it returns the null value. Constant* getZeroValueForNegation(const Type* Ty); // ConstantFP accessors ConstantFP* getConstantFP(const APFloat& V); + + /// get() - This returns a ConstantFP, or a vector containing a splat of a + /// ConstantFP, for the specified value in the specified type. This should + /// only be used for simple constant values like 2.0/1.0 etc, that are + /// known-valid both as host double and as the target format. Constant* getConstantFP(const Type* Ty, double V); ConstantFP* getConstantFPNegativeZero(const Type* Ty); @@ -166,9 +227,16 @@ public: const std::vector& V); Constant* getConstantVector(const std::vector& V); Constant* getConstantVector(Constant* const* Vals, unsigned NumVals); - ConstantVector* getConstantVectorAllOnes(const VectorType* Ty); + + // MDNode accessors + MDNode* getMDNode(Value* const* Vals, unsigned NumVals); + + // MDString accessors + MDString* getMDString(const char *StrBegin, const char *StrEnd); + MDString* getMDString(const std::string &Str); // FunctionType accessors + FunctionType* getFunctionType(const Type* Result, bool isVarArg); FunctionType* getFunctionType(const Type* Result, const std::vector& Params, bool isVarArg); @@ -180,25 +248,41 @@ public: OpaqueType* getOpaqueType(); // StructType accessors + StructType* getStructType(bool isPacked=false); StructType* getStructType(const std::vector& Params, bool isPacked = false); + StructType* getStructType(const Type* type, ...); // ArrayType accessors ArrayType* getArrayType(const Type* ElementType, uint64_t NumElements); // PointerType accessors PointerType* getPointerType(const Type* ElementType, unsigned AddressSpace); - PointerType* getPointerTypeUnqualified(const Type* ElementType); + PointerType* getPointerTypeUnqual(const Type* ElementType); // VectorType accessors VectorType* getVectorType(const Type* ElementType, unsigned NumElements); VectorType* getVectorTypeInteger(const VectorType* VTy); VectorType* getVectorTypeExtendedElement(const VectorType* VTy); VectorType* getVectorTypeTruncatedElement(const VectorType* VTy); + + // Other helpers + /// @brief Create a result type for fcmp/icmp + const Type* makeCmpResultType(const Type* opnd_type); + + // Methods for erasing constants + void erase(MDString *M); + void erase(MDNode *M); + void erase(ConstantAggregateZero *Z); + void erase(ConstantArray *Z); + + // RAUW helpers + Constant *replaceUsesOfWithOnConstant(ConstantArray *CA, + Value *From, Value *To, Use *U); }; /// FOR BACKWARDS COMPATIBILITY - Returns a global context. -extern const LLVMContext& getGlobalContext(); +extern LLVMContext& getGlobalContext(); }