1 //===-- llvm/LLVMContext.h - Class for managing "global" state --*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file declares LLVMContext, a container of "global" state in LLVM, such
11 // as the global type and constant uniquing tables.
13 //===----------------------------------------------------------------------===//
15 #ifndef LLVM_LLVMCONTEXT_H
16 #define LLVM_LLVMCONTEXT_H
18 #include "llvm/Support/DataTypes.h"
24 class LLVMContextImpl;
27 class ConstantPointerNull;
29 class ConstantAggregateZero;
49 /// This is an important class for using LLVM in a threaded context. It
50 /// (opaquely) owns and manages the core "global" data of LLVM's core
51 /// infrastructure, including the type and constant uniquing tables.
52 /// LLVMContext itself provides no locking guarantees, so you should be careful
53 /// to have one context per thread.
55 LLVMContextImpl* pImpl;
61 Constant* getNullValue(const Type* Ty);
63 /// @returns the value for an integer constant of the given type that has all
64 /// its bits set to true.
65 /// @brief Get the all ones value
66 Constant* getAllOnesValue(const Type* Ty);
68 // UndefValue accessors
69 UndefValue* getUndef(const Type* Ty);
71 // ConstantInt accessors
72 ConstantInt* getTrue();
73 ConstantInt* getFalse();
75 /// If Ty is a vector type, return a Constant with a splat of the given
76 /// value. Otherwise return a ConstantInt for the given value.
77 Constant* getConstantInt(const Type* Ty, uint64_t V,
78 bool isSigned = false);
80 /// Return a ConstantInt with the specified integer value for the specified
81 /// type. If the type is wider than 64 bits, the value will be zero-extended
82 /// to fit the type, unless isSigned is true, in which case the value will
83 /// be interpreted as a 64-bit signed integer and sign-extended to fit
85 /// @brief Get a ConstantInt for a specific value.
86 ConstantInt* getConstantInt(const IntegerType* Ty, uint64_t V,
87 bool isSigned = false);
89 /// Return a ConstantInt with the specified value for the specified type. The
90 /// value V will be canonicalized to a an unsigned APInt. Accessing it with
91 /// either getSExtValue() or getZExtValue() will yield a correctly sized and
92 /// signed value for the type Ty.
93 /// @brief Get a ConstantInt for a specific signed value.
94 ConstantInt* getConstantIntSigned(const IntegerType* Ty, int64_t V);
95 Constant *getConstantIntSigned(const Type *Ty, int64_t V);
97 /// Return a ConstantInt with the specified value and an implied Type. The
98 /// type is the integer type that corresponds to the bit width of the value.
99 ConstantInt* getConstantInt(const APInt& V);
101 /// If Ty is a vector type, return a Constant with a splat of the given
102 /// value. Otherwise return a ConstantInt for the given value.
103 Constant* getConstantInt(const Type* Ty, const APInt& V);
105 // ConstantPointerNull accessors
106 ConstantPointerNull* getConstantPointerNull(const PointerType* T);
108 // ConstantStruct accessors
109 Constant* getConstantStruct(const StructType* T,
110 const std::vector<Constant*>& V);
111 Constant* getConstantStruct(const std::vector<Constant*>& V,
112 bool Packed = false);
113 Constant* getConstantStruct(Constant* const *Vals, unsigned NumVals,
114 bool Packed = false);
116 // ConstantAggregateZero accessors
117 ConstantAggregateZero* getConstantAggregateZero(const Type* Ty);
119 // ConstantArray accessors
120 Constant* getConstantArray(const ArrayType* T,
121 const std::vector<Constant*>& V);
122 Constant* getConstantArray(const ArrayType* T, Constant* const* Vals,
125 /// This method constructs a ConstantArray and initializes it with a text
126 /// string. The default behavior (AddNull==true) causes a null terminator to
127 /// be placed at the end of the array. This effectively increases the length
128 /// of the array by one (you've been warned). However, in some situations
129 /// this is not desired so if AddNull==false then the string is copied without
130 /// null termination.
131 Constant* getConstantArray(const std::string& Initializer,
132 bool AddNull = true);
134 // ConstantExpr accessors
135 Constant* getConstantExpr(unsigned Opcode, Constant* C1, Constant* C2);
136 Constant* getConstantExprTrunc(Constant* C, const Type* Ty);
137 Constant* getConstantExprSExt(Constant* C, const Type* Ty);
138 Constant* getConstantExprZExt(Constant* C, const Type* Ty);
139 Constant* getConstantExprFPTrunc(Constant* C, const Type* Ty);
140 Constant* getConstantExprFPExtend(Constant* C, const Type* Ty);
141 Constant* getConstantExprUIToFP(Constant* C, const Type* Ty);
142 Constant* getConstantExprSIToFP(Constant* C, const Type* Ty);
143 Constant* getConstantExprFPToUI(Constant* C, const Type* Ty);
144 Constant* getConstantExprFPToSI(Constant* C, const Type* Ty);
145 Constant* getConstantExprPtrToInt(Constant* C, const Type* Ty);
146 Constant* getConstantExprIntToPtr(Constant* C, const Type* Ty);
147 Constant* getConstantExprBitCast(Constant* C, const Type* Ty);
148 Constant* getConstantExprCast(unsigned ops, Constant* C, const Type* Ty);
149 Constant* getConstantExprZExtOrBitCast(Constant* C, const Type* Ty);
150 Constant* getConstantExprSExtOrBitCast(Constant* C, const Type* Ty);
151 Constant* getConstantExprTruncOrBitCast(Constant* C, const Type* Ty);
152 Constant* getConstantExprPointerCast(Constant* C, const Type* Ty);
153 Constant* getConstantExprIntegerCast(Constant* C, const Type* Ty,
155 Constant* getConstantExprFPCast(Constant* C, const Type* Ty);
156 Constant* getConstantExprSelect(Constant* C, Constant* V1, Constant* V2);
158 /// getAlignOf constant expr - computes the alignment of a type in a target
159 /// independent way (Note: the return type is an i32; Note: assumes that i8
160 /// is byte aligned).
162 Constant* getConstantExprAlignOf(const Type* Ty);
163 Constant* getConstantExprCompare(unsigned short pred,
164 Constant* C1, Constant* C2);
165 Constant* getConstantExprNeg(Constant* C);
166 Constant* getConstantExprFNeg(Constant* C);
167 Constant* getConstantExprNot(Constant* C);
168 Constant* getConstantExprAdd(Constant* C1, Constant* C2);
169 Constant* getConstantExprFAdd(Constant* C1, Constant* C2);
170 Constant* getConstantExprSub(Constant* C1, Constant* C2);
171 Constant* getConstantExprFSub(Constant* C1, Constant* C2);
172 Constant* getConstantExprMul(Constant* C1, Constant* C2);
173 Constant* getConstantExprFMul(Constant* C1, Constant* C2);
174 Constant* getConstantExprUDiv(Constant* C1, Constant* C2);
175 Constant* getConstantExprSDiv(Constant* C1, Constant* C2);
176 Constant* getConstantExprFDiv(Constant* C1, Constant* C2);
177 Constant* getConstantExprURem(Constant* C1, Constant* C2);
178 Constant* getConstantExprSRem(Constant* C1, Constant* C2);
179 Constant* getConstantExprFRem(Constant* C1, Constant* C2);
180 Constant* getConstantExprAnd(Constant* C1, Constant* C2);
181 Constant* getConstantExprOr(Constant* C1, Constant* C2);
182 Constant* getConstantExprXor(Constant* C1, Constant* C2);
183 Constant* getConstantExprICmp(unsigned short pred, Constant* LHS,
185 Constant* getConstantExprFCmp(unsigned short pred, Constant* LHS,
187 Constant* getConstantExprShl(Constant* C1, Constant* C2);
188 Constant* getConstantExprLShr(Constant* C1, Constant* C2);
189 Constant* getConstantExprAShr(Constant* C1, Constant* C2);
190 Constant* getConstantExprGetElementPtr(Constant* C, Constant* const* IdxList,
192 Constant* getConstantExprGetElementPtr(Constant* C, Value* const* IdxList,
194 Constant* getConstantExprExtractElement(Constant* Vec, Constant* Idx);
195 Constant* getConstantExprInsertElement(Constant* Vec, Constant* Elt,
197 Constant* getConstantExprShuffleVector(Constant* V1, Constant* V2,
199 Constant* getConstantExprExtractValue(Constant* Agg, const unsigned* IdxList,
201 Constant* getConstantExprInsertValue(Constant* Agg, Constant* Val,
202 const unsigned* IdxList,
205 /// getSizeOf constant expr - computes the size of a type in a target
206 /// independent way (Note: the return type is an i64).
208 Constant* getConstantExprSizeOf(const Type* Ty);
210 /// Floating point negation must be implemented with f(x) = -0.0 - x. This
211 /// method returns the negative zero constant for floating point or vector
212 /// floating point types; for all other types, it returns the null value.
213 Constant* getZeroValueForNegation(const Type* Ty);
215 // ConstantFP accessors
216 ConstantFP* getConstantFP(const APFloat& V);
218 /// get() - This returns a ConstantFP, or a vector containing a splat of a
219 /// ConstantFP, for the specified value in the specified type. This should
220 /// only be used for simple constant values like 2.0/1.0 etc, that are
221 /// known-valid both as host double and as the target format.
222 Constant* getConstantFP(const Type* Ty, double V);
223 ConstantFP* getConstantFPNegativeZero(const Type* Ty);
225 // ConstantVector accessors
226 Constant* getConstantVector(const VectorType* T,
227 const std::vector<Constant*>& V);
228 Constant* getConstantVector(const std::vector<Constant*>& V);
229 Constant* getConstantVector(Constant* const* Vals, unsigned NumVals);
232 MDNode* getMDNode(Value* const* Vals, unsigned NumVals);
234 // MDString accessors
235 MDString* getMDString(const char *StrBegin, const char *StrEnd);
236 MDString* getMDString(const std::string &Str);
238 // FunctionType accessors
239 FunctionType* getFunctionType(const Type* Result, bool isVarArg);
240 FunctionType* getFunctionType(const Type* Result,
241 const std::vector<const Type*>& Params,
244 // IntegerType accessors
245 const IntegerType* getIntegerType(unsigned NumBits);
247 // OpaqueType accessors
248 OpaqueType* getOpaqueType();
250 // StructType accessors
251 StructType* getStructType(bool isPacked=false);
252 StructType* getStructType(const std::vector<const Type*>& Params,
253 bool isPacked = false);
254 StructType* getStructType(const Type* type, ...);
256 // ArrayType accessors
257 ArrayType* getArrayType(const Type* ElementType, uint64_t NumElements);
259 // PointerType accessors
260 PointerType* getPointerType(const Type* ElementType, unsigned AddressSpace);
261 PointerType* getPointerTypeUnqual(const Type* ElementType);
263 // VectorType accessors
264 VectorType* getVectorType(const Type* ElementType, unsigned NumElements);
265 VectorType* getVectorTypeInteger(const VectorType* VTy);
266 VectorType* getVectorTypeExtendedElement(const VectorType* VTy);
267 VectorType* getVectorTypeTruncatedElement(const VectorType* VTy);
270 /// @brief Create a result type for fcmp/icmp
271 const Type* makeCmpResultType(const Type* opnd_type);
273 // Methods for erasing constants
274 void erase(MDString *M);
275 void erase(MDNode *M);
276 void erase(ConstantAggregateZero *Z);
277 void erase(ConstantArray *Z);
280 Constant *replaceUsesOfWithOnConstant(ConstantArray *CA,
281 Value *From, Value *To, Use *U);
284 /// FOR BACKWARDS COMPATIBILITY - Returns a global context.
285 extern LLVMContext& getGlobalContext();