1 //===-- LLVMContextImpl.h - The LLVMContextImpl opaque class ----*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 //  This file declares LLVMContextImpl, the opaque implementation
11 //  of LLVMContext.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef LLVM_LIB_IR_LLVMCONTEXTIMPL_H
16 #define LLVM_LIB_IR_LLVMCONTEXTIMPL_H
17 
18 #include "AttributeImpl.h"
19 #include "ConstantsContext.h"
20 #include "LeaksContext.h"
21 #include "llvm/ADT/APFloat.h"
22 #include "llvm/ADT/APInt.h"
23 #include "llvm/ADT/ArrayRef.h"
24 #include "llvm/ADT/DenseMap.h"
25 #include "llvm/ADT/FoldingSet.h"
26 #include "llvm/ADT/Hashing.h"
27 #include "llvm/ADT/SmallPtrSet.h"
28 #include "llvm/ADT/StringMap.h"
29 #include "llvm/IR/Constants.h"
30 #include "llvm/IR/DerivedTypes.h"
31 #include "llvm/IR/LLVMContext.h"
32 #include "llvm/IR/Metadata.h"
33 #include "llvm/IR/ValueHandle.h"
34 #include <vector>
35 
36 namespace llvm {
37 
38 class ConstantInt;
39 class ConstantFP;
40 class DiagnosticInfoOptimizationRemark;
41 class DiagnosticInfoOptimizationRemarkMissed;
42 class DiagnosticInfoOptimizationRemarkAnalysis;
43 class LLVMContext;
44 class Type;
45 class Value;
46 
47 struct DenseMapAPIntKeyInfo {
48   struct KeyTy {
49     APInt val;
50     Type* type;
51     KeyTy(const APInt& V, Type* Ty) : val(V), type(Ty) {}
52     bool operator==(const KeyTy& that) const {
53       return type == that.type && this->val == that.val;
54     }
55     bool operator!=(const KeyTy& that) const {
56       return !this->operator==(that);
57     }
58     friend hash_code hash_value(const KeyTy &Key) {
59       return hash_combine(Key.type, Key.val);
60     }
61   };
62   static inline KeyTy getEmptyKey() { return KeyTy(APInt(1,0), nullptr); }
63   static inline KeyTy getTombstoneKey() { return KeyTy(APInt(1,1), nullptr); }
64   static unsigned getHashValue(const KeyTy &Key) {
65     return static_cast<unsigned>(hash_value(Key));
66   }
67   static bool isEqual(const KeyTy &LHS, const KeyTy &RHS) {
68     return LHS == RHS;
69   }
70 };
71 
72 struct DenseMapAPFloatKeyInfo {
73   struct KeyTy {
74     APFloat val;
75     KeyTy(const APFloat& V) : val(V){}
76     bool operator==(const KeyTy& that) const {
77       return this->val.bitwiseIsEqual(that.val);
78     }
79     bool operator!=(const KeyTy& that) const {
80       return !this->operator==(that);
81     }
82     friend hash_code hash_value(const KeyTy &Key) {
83       return hash_combine(Key.val);
84     }
85   };
86   static inline KeyTy getEmptyKey() {
87     return KeyTy(APFloat(APFloat::Bogus,1));
88   }
89   static inline KeyTy getTombstoneKey() {
90     return KeyTy(APFloat(APFloat::Bogus,2));
91   }
92   static unsigned getHashValue(const KeyTy &Key) {
93     return static_cast<unsigned>(hash_value(Key));
94   }
95   static bool isEqual(const KeyTy &LHS, const KeyTy &RHS) {
96     return LHS == RHS;
97   }
98 };
99 
100 struct AnonStructTypeKeyInfo {
101   struct KeyTy {
102     ArrayRef<Type*> ETypes;
103     bool isPacked;
104     KeyTy(const ArrayRef<Type*>& E, bool P) :
105       ETypes(E), isPacked(P) {}
106     KeyTy(const StructType* ST) :
107       ETypes(ArrayRef<Type*>(ST->element_begin(), ST->element_end())),
108       isPacked(ST->isPacked()) {}
109     bool operator==(const KeyTy& that) const {
110       if (isPacked != that.isPacked)
111         return false;
112       if (ETypes != that.ETypes)
113         return false;
114       return true;
115     }
116     bool operator!=(const KeyTy& that) const {
117       return !this->operator==(that);
118     }
119   };
120   static inline StructType* getEmptyKey() {
121     return DenseMapInfo<StructType*>::getEmptyKey();
122   }
123   static inline StructType* getTombstoneKey() {
124     return DenseMapInfo<StructType*>::getTombstoneKey();
125   }
126   static unsigned getHashValue(const KeyTy& Key) {
127     return hash_combine(hash_combine_range(Key.ETypes.begin(),
128                                            Key.ETypes.end()),
129                         Key.isPacked);
130   }
131   static unsigned getHashValue(const StructType *ST) {
132     return getHashValue(KeyTy(ST));
133   }
134   static bool isEqual(const KeyTy& LHS, const StructType *RHS) {
135     if (RHS == getEmptyKey() || RHS == getTombstoneKey())
136       return false;
137     return LHS == KeyTy(RHS);
138   }
139   static bool isEqual(const StructType *LHS, const StructType *RHS) {
140     return LHS == RHS;
141   }
142 };
143 
144 struct FunctionTypeKeyInfo {
145   struct KeyTy {
146     const Type *ReturnType;
147     ArrayRef<Type*> Params;
148     bool isVarArg;
149     KeyTy(const Type* R, const ArrayRef<Type*>& P, bool V) :
150       ReturnType(R), Params(P), isVarArg(V) {}
151     KeyTy(const FunctionType* FT) :
152       ReturnType(FT->getReturnType()),
153       Params(makeArrayRef(FT->param_begin(), FT->param_end())),
154       isVarArg(FT->isVarArg()) {}
155     bool operator==(const KeyTy& that) const {
156       if (ReturnType != that.ReturnType)
157         return false;
158       if (isVarArg != that.isVarArg)
159         return false;
160       if (Params != that.Params)
161         return false;
162       return true;
163     }
164     bool operator!=(const KeyTy& that) const {
165       return !this->operator==(that);
166     }
167   };
168   static inline FunctionType* getEmptyKey() {
169     return DenseMapInfo<FunctionType*>::getEmptyKey();
170   }
171   static inline FunctionType* getTombstoneKey() {
172     return DenseMapInfo<FunctionType*>::getTombstoneKey();
173   }
174   static unsigned getHashValue(const KeyTy& Key) {
175     return hash_combine(Key.ReturnType,
176                         hash_combine_range(Key.Params.begin(),
177                                            Key.Params.end()),
178                         Key.isVarArg);
179   }
180   static unsigned getHashValue(const FunctionType *FT) {
181     return getHashValue(KeyTy(FT));
182   }
183   static bool isEqual(const KeyTy& LHS, const FunctionType *RHS) {
184     if (RHS == getEmptyKey() || RHS == getTombstoneKey())
185       return false;
186     return LHS == KeyTy(RHS);
187   }
188   static bool isEqual(const FunctionType *LHS, const FunctionType *RHS) {
189     return LHS == RHS;
190   }
191 };
192 
193 // Provide a FoldingSetTrait::Equals specialization for MDNode that can use a
194 // shortcut to avoid comparing all operands.
195 template<> struct FoldingSetTrait<MDNode> : DefaultFoldingSetTrait<MDNode> {
196   static bool Equals(const MDNode &X, const FoldingSetNodeID &ID,
197                      unsigned IDHash, FoldingSetNodeID &TempID) {
198     assert(!X.isNotUniqued() && "Non-uniqued MDNode in FoldingSet?");
199     // First, check if the cached hashes match.  If they don't we can skip the
200     // expensive operand walk.
201     if (X.Hash != IDHash)
202       return false;
203 
204     // If they match we have to compare the operands.
205     X.Profile(TempID);
206     return TempID == ID;
207   }
208   static unsigned ComputeHash(const MDNode &X, FoldingSetNodeID &) {
209     return X.Hash; // Return cached hash.
210   }
211 };
212 
213 /// DebugRecVH - This is a CallbackVH used to keep the Scope -> index maps
214 /// up to date as MDNodes mutate.  This class is implemented in DebugLoc.cpp.
215 class DebugRecVH : public CallbackVH {
216   /// Ctx - This is the LLVM Context being referenced.
217   LLVMContextImpl *Ctx;
218 
219   /// Idx - The index into either ScopeRecordIdx or ScopeInlinedAtRecords that
220   /// this reference lives in.  If this is zero, then it represents a
221   /// non-canonical entry that has no DenseMap value.  This can happen due to
222   /// RAUW.
223   int Idx;
224 public:
225   DebugRecVH(MDNode *n, LLVMContextImpl *ctx, int idx)
226     : CallbackVH(n), Ctx(ctx), Idx(idx) {}
227 
228   MDNode *get() const {
229     return cast_or_null<MDNode>(getValPtr());
230   }
231 
232   void deleted() override;
233   void allUsesReplacedWith(Value *VNew) override;
234 };
235 
236 class LLVMContextImpl {
237 public:
238   /// OwnedModules - The set of modules instantiated in this context, and which
239   /// will be automatically deleted if this context is deleted.
240   SmallPtrSet<Module*, 4> OwnedModules;
241 
242   LLVMContext::InlineAsmDiagHandlerTy InlineAsmDiagHandler;
243   void *InlineAsmDiagContext;
244 
245   LLVMContext::DiagnosticHandlerTy DiagnosticHandler;
246   void *DiagnosticContext;
247   bool RespectDiagnosticFilters;
248 
249   LLVMContext::YieldCallbackTy YieldCallback;
250   void *YieldOpaqueHandle;
251 
252   typedef DenseMap<DenseMapAPIntKeyInfo::KeyTy, ConstantInt *,
253                    DenseMapAPIntKeyInfo> IntMapTy;
254   IntMapTy IntConstants;
255 
256   typedef DenseMap<DenseMapAPFloatKeyInfo::KeyTy, ConstantFP*,
257                          DenseMapAPFloatKeyInfo> FPMapTy;
258   FPMapTy FPConstants;
259 
260   FoldingSet<AttributeImpl> AttrsSet;
261   FoldingSet<AttributeSetImpl> AttrsLists;
262   FoldingSet<AttributeSetNode> AttrsSetNodes;
263 
264   StringMap<Value*> MDStringCache;
265 
266   FoldingSet<MDNode> MDNodeSet;
267 
268   // MDNodes may be uniqued or not uniqued.  When they're not uniqued, they
269   // aren't in the MDNodeSet, but they're still shared between objects, so no
270   // one object can destroy them.  This set allows us to at least destroy them
271   // on Context destruction.
272   SmallPtrSet<MDNode*, 1> NonUniquedMDNodes;
273 
274   DenseMap<Type*, ConstantAggregateZero*> CAZConstants;
275 
276   typedef ConstantUniqueMap<ConstantArray> ArrayConstantsTy;
277   ArrayConstantsTy ArrayConstants;
278 
279   typedef ConstantUniqueMap<ConstantStruct> StructConstantsTy;
280   StructConstantsTy StructConstants;
281 
282   typedef ConstantUniqueMap<ConstantVector> VectorConstantsTy;
283   VectorConstantsTy VectorConstants;
284 
285   DenseMap<PointerType*, ConstantPointerNull*> CPNConstants;
286 
287   DenseMap<Type*, UndefValue*> UVConstants;
288 
289   StringMap<ConstantDataSequential*> CDSConstants;
290 
291   DenseMap<std::pair<const Function *, const BasicBlock *>, BlockAddress *>
292     BlockAddresses;
293   ConstantUniqueMap<ConstantExpr> ExprConstants;
294 
295   ConstantUniqueMap<InlineAsm> InlineAsms;
296 
297   ConstantInt *TheTrueVal;
298   ConstantInt *TheFalseVal;
299 
300   LeakDetectorImpl<Value> LLVMObjects;
301 
302   // Basic type instances.
303   Type VoidTy, LabelTy, HalfTy, FloatTy, DoubleTy, MetadataTy;
304   Type X86_FP80Ty, FP128Ty, PPC_FP128Ty, X86_MMXTy;
305   IntegerType Int1Ty, Int8Ty, Int16Ty, Int32Ty, Int64Ty;
306 
307 
308   /// TypeAllocator - All dynamically allocated types are allocated from this.
309   /// They live forever until the context is torn down.
310   BumpPtrAllocator TypeAllocator;
311 
312   DenseMap<unsigned, IntegerType*> IntegerTypes;
313 
314   typedef DenseMap<FunctionType*, bool, FunctionTypeKeyInfo> FunctionTypeMap;
315   FunctionTypeMap FunctionTypes;
316   typedef DenseMap<StructType*, bool, AnonStructTypeKeyInfo> StructTypeMap;
317   StructTypeMap AnonStructTypes;
318   StringMap<StructType*> NamedStructTypes;
319   unsigned NamedStructTypesUniqueID;
320 
321   DenseMap<std::pair<Type *, uint64_t>, ArrayType*> ArrayTypes;
322   DenseMap<std::pair<Type *, unsigned>, VectorType*> VectorTypes;
323   DenseMap<Type*, PointerType*> PointerTypes;  // Pointers in AddrSpace = 0
324   DenseMap<std::pair<Type*, unsigned>, PointerType*> ASPointerTypes;
325 
326 
327   /// ValueHandles - This map keeps track of all of the value handles that are
328   /// watching a Value*.  The Value::HasValueHandle bit is used to know
329   /// whether or not a value has an entry in this map.
330   typedef DenseMap<Value*, ValueHandleBase*> ValueHandlesTy;
331   ValueHandlesTy ValueHandles;
332 
333   /// CustomMDKindNames - Map to hold the metadata string to ID mapping.
334   StringMap<unsigned> CustomMDKindNames;
335 
336   typedef std::pair<unsigned, TrackingVH<MDNode> > MDPairTy;
337   typedef SmallVector<MDPairTy, 2> MDMapTy;
338 
339   /// MetadataStore - Collection of per-instruction metadata used in this
340   /// context.
341   DenseMap<const Instruction *, MDMapTy> MetadataStore;
342 
343   /// ScopeRecordIdx - This is the index in ScopeRecords for an MDNode scope
344   /// entry with no "inlined at" element.
345   DenseMap<MDNode*, int> ScopeRecordIdx;
346 
347   /// ScopeRecords - These are the actual mdnodes (in a value handle) for an
348   /// index.  The ValueHandle ensures that ScopeRecordIdx stays up to date if
349   /// the MDNode is RAUW'd.
350   std::vector<DebugRecVH> ScopeRecords;
351 
352   /// ScopeInlinedAtIdx - This is the index in ScopeInlinedAtRecords for an
353   /// scope/inlined-at pair.
354   DenseMap<std::pair<MDNode*, MDNode*>, int> ScopeInlinedAtIdx;
355 
356   /// ScopeInlinedAtRecords - These are the actual mdnodes (in value handles)
357   /// for an index.  The ValueHandle ensures that ScopeINlinedAtIdx stays up
358   /// to date.
359   std::vector<std::pair<DebugRecVH, DebugRecVH> > ScopeInlinedAtRecords;
360 
361   /// DiscriminatorTable - This table maps file:line locations to an
362   /// integer representing the next DWARF path discriminator to assign to
363   /// instructions in different blocks at the same location.
364   DenseMap<std::pair<const char *, unsigned>, unsigned> DiscriminatorTable;
365 
366   /// IntrinsicIDCache - Cache of intrinsic name (string) to numeric ID mappings
367   /// requested in this context
368   typedef DenseMap<const Function*, unsigned> IntrinsicIDCacheTy;
369   IntrinsicIDCacheTy IntrinsicIDCache;
370 
371   /// \brief Mapping from a function to its prefix data, which is stored as the
372   /// operand of an unparented ReturnInst so that the prefix data has a Use.
373   typedef DenseMap<const Function *, ReturnInst *> PrefixDataMapTy;
374   PrefixDataMapTy PrefixDataMap;
375 
376   int getOrAddScopeRecordIdxEntry(MDNode *N, int ExistingIdx);
377   int getOrAddScopeInlinedAtIdxEntry(MDNode *Scope, MDNode *IA,int ExistingIdx);
378 
379   LLVMContextImpl(LLVMContext &C);
380   ~LLVMContextImpl();
381 };
382 
383 }
384 
385 #endif
386