LLVM: lib/IR/LLVMContextImpl.cpp Source File

LLVM 22.0.0git
LLVMContextImpl.cpp
Go to the documentation of this file.
1//===- LLVMContextImpl.cpp - Implement LLVMContextImpl --------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements the opaque LLVMContextImpl.
10//
11//===----------------------------------------------------------------------===//
12
13#include "LLVMContextImpl.h"
14#include "AttributeImpl.h"
15#include "llvm/ADT/StringMapEntry.h"
16#include "llvm/ADT/iterator.h"
17#include "llvm/IR/DiagnosticHandler.h"
18#include "llvm/IR/LLVMRemarkStreamer.h"
19#include "llvm/IR/Module.h"
20#include "llvm/IR/OptBisect.h"
21#include "llvm/IR/Type.h"
22#include "llvm/IR/Use.h"
23#include "llvm/IR/User.h"
24#include "llvm/Remarks/RemarkStreamer.h"
25#include "llvm/Support/Compiler.h"
26#include "llvm/Support/ErrorHandling.h"
27#include <cassert>
28#include <utility>
29
30using namespace llvm;
31
33 : DiagHandler(std::make_unique<DiagnosticHandler>()),
34 VoidTy(C, Type::VoidTyID), LabelTy(C, Type::LabelTyID),
35 HalfTy(C, Type::HalfTyID), BFloatTy(C, Type::BFloatTyID),
37 MetadataTy(C, Type::MetadataTyID), TokenTy(C, Type::TokenTyID),
38 X86_FP80Ty(C, Type::X86_FP80TyID), FP128Ty(C, Type::FP128TyID),
39 PPC_FP128Ty(C, Type::PPC_FP128TyID), X86_AMXTy(C, Type::X86_AMXTyID),
40 Int1Ty(C, 1), Int8Ty(C, 8), Int16Ty(C, 16), Int32Ty(C, 32),
41 Int64Ty(C, 64), Int128Ty(C, 128) {}
42
44#ifndef NDEBUG
45 // Check that any variable location records that fell off the end of a block
46 // when it's terminator was removed were eventually replaced. This assertion
47 // firing indicates that DbgVariableRecords went missing during the lifetime
48 // of the LLVMContext.
49 assert(TrailingDbgRecords.empty() && "DbgRecords in blocks not cleaned");
50#endif
51
52 // NOTE: We need to delete the contents of OwnedModules, but Module's dtor
53 // will call LLVMContextImpl::removeModule, thus invalidating iterators into
54 // the container. Avoid iterators during this operation:
55 while (!OwnedModules.empty())
56 delete *OwnedModules.begin();
57
58#ifndef NDEBUG
59 // Check for metadata references from leaked Values.
60 for (auto &Pair : ValueMetadata)
61 Pair.first->dump();
62 assert(ValueMetadata.empty() && "Values with metadata have been leaked");
63#endif
64
65 // Drop references for MDNodes. Do this before Values get deleted to avoid
66 // unnecessary RAUW when nodes are still unresolved.
67 for (auto *I : DistinctMDNodes)
68 I->dropAllReferences();
69#define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS) \
70 for (auto *I : CLASS##s) \
71 I->dropAllReferences();
72#include "llvm/IR/Metadata.def"
73
74 // Also drop references that come from the Value bridges.
75 for (auto &Pair : ValuesAsMetadata)
76 Pair.second->dropUsers();
77 for (auto &Pair : MetadataAsValues)
78 Pair.second->dropUse();
79 // Do not untrack ValueAsMetadata references for DIArgLists, as they have
80 // already been more efficiently untracked above.
81 for (DIArgList *AL : DIArgLists) {
82 AL->dropAllReferences(/* Untrack */ false);
83 delete AL;
84 }
85 DIArgLists.clear();
86
87 // Destroy MDNodes.
88 for (MDNode *I : DistinctMDNodes)
89 I->deleteAsSubclass();
90
91 for (auto *ConstantRangeListAttribute : ConstantRangeListAttributes)
92 ConstantRangeListAttribute->~ConstantRangeListAttributeImpl();
93#define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS) \
94 for (CLASS * I : CLASS##s) \
95 delete I;
96#include "llvm/IR/Metadata.def"
97
98 // Free the constants.
99 for (auto *I : ExprConstants)
100 I->dropAllReferences();
101 for (auto *I : ArrayConstants)
102 I->dropAllReferences();
103 for (auto *I : StructConstants)
104 I->dropAllReferences();
105 for (auto *I : VectorConstants)
106 I->dropAllReferences();
107 ExprConstants.freeConstants();
108 ArrayConstants.freeConstants();
109 StructConstants.freeConstants();
110 VectorConstants.freeConstants();
111 InlineAsms.freeConstants();
112
113 CAZConstants.clear();
114 CPNConstants.clear();
115 CTNConstants.clear();
116 UVConstants.clear();
117 PVConstants.clear();
118 IntZeroConstants.clear();
119 IntOneConstants.clear();
120 IntConstants.clear();
121 IntSplatConstants.clear();
122 FPConstants.clear();
123 FPSplatConstants.clear();
124 CDSConstants.clear();
125
126 // Destroy attribute node lists.
128 E = AttrsSetNodes.end(); I != E; ) {
130 delete &*Elem;
131 }
132
133 // Destroy MetadataAsValues.
134 {
136 MDVs.reserve(MetadataAsValues.size());
137 for (auto &Pair : MetadataAsValues)
138 MDVs.push_back(Pair.second);
139 MetadataAsValues.clear();
140 for (auto *V : MDVs)
141 delete V;
142 }
143
144 // Destroy ValuesAsMetadata.
145 for (auto &Pair : ValuesAsMetadata)
146 delete Pair.second;
147}
148
149namespace llvm {
150
151/// Make MDOperand transparent for hashing.
152///
153/// This overload of an implementation detail of the hashing library makes
154/// MDOperand hash to the same value as a \a Metadata pointer.
155///
156/// Note that overloading \a hash_value() as follows:
157///
158/// \code
159/// size_t hash_value(const MDOperand &X) { return hash_value(X.get()); }
160/// \endcode
161///
162/// does not cause MDOperand to be transparent. In particular, a bare pointer
163/// doesn't get hashed before it's combined, whereas \a MDOperand would.
164 static const Metadata *get_hashable_data(const MDOperand &X) { return X.get(); }
165
166} // end namespace llvm
167
169 unsigned Hash = hash_combine_range(N->op_begin() + Offset, N->op_end());
170#ifndef NDEBUG
171 {
173 unsigned RawHash = calculateHash(MDs);
174 assert(Hash == RawHash &&
175 "Expected hash of MDOperand to equal hash of Metadata*");
176 }
177#endif
178 return Hash;
179}
180
181unsigned MDNodeOpsKey::calculateHash(ArrayRef<Metadata *> Ops) {
182 return hash_combine_range(Ops);
183}
184
186 uint32_t NewIdx = BundleTagCache.size();
187 return &*(BundleTagCache.insert(std::make_pair(Tag, NewIdx)).first);
188}
189
191 Tags.resize(BundleTagCache.size());
192 for (const auto &T : BundleTagCache)
193 Tags[T.second] = T.first();
194}
195
197 auto I = BundleTagCache.find(Tag);
198 assert(I != BundleTagCache.end() && "Unknown tag!");
199 return I->second;
200}
201
203 auto NewSSID = SSC.size();
204 assert(NewSSID < std::numeric_limits<SyncScope::ID>::max() &&
205 "Hit the maximum number of synchronization scopes allowed!");
206 return SSC.insert(std::make_pair(SSN, SyncScope::ID(NewSSID))).first->second;
207}
208
210 SmallVectorImpl<StringRef> &SSNs) const {
211 SSNs.resize(SSC.size());
212 for (const auto &SSE : SSC)
213 SSNs[SSE.second] = SSE.first();
214}
215
216std::optional<StringRef>
218 for (const auto &SSE : SSC) {
219 if (SSE.second != Id)
220 continue;
221 return SSE.first();
222 }
223 return std::nullopt;
224}
225
226/// Gets the OptPassGate for this LLVMContextImpl, which defaults to the
227/// singleton OptBisect if not explicitly set.
229 if (!OPG)
231 return *OPG;
232}
233
235 this->OPG = &OPG;
236}
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
This file defines the StringMapEntry class - it is intended to be a low dependency implementation det...
This file defines various helper methods and classes used by LLVMContextImpl for creating and managin...
Module.h This file contains the declarations for the Module class.
This defines the Use class.
const AbstractManglingParser< Derived, Alloc >::OperatorInfo AbstractManglingParser< Derived, Alloc >::Ops[]
I
#define I(x, y, z)
Definition MD5.cpp:58
const Type::TypeID FloatTyID
const Type::TypeID DoubleTyID
T
#define T
This file declares the interface for bisecting optimizations.
X
static TableGen::Emitter::OptClass< SkeletonEmitter > X("gen-skeleton-class", "Generate example skeleton class")
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition ArrayRef.h:41
List of ValueAsMetadata, to be used as an argument to a dbg.value intrinsic.
DenseMap< unsigned, std::unique_ptr< ConstantInt > > IntOneConstants
void getSyncScopeNames(SmallVectorImpl< StringRef > &SSNs) const
getSyncScopeNames - Populates client supplied SmallVector with synchronization scope names registered...
DenseMap< unsigned, std::unique_ptr< ConstantInt > > IntZeroConstants
DenseMap< Metadata *, MetadataAsValue * > MetadataAsValues
DenseMap< APFloat, std::unique_ptr< ConstantFP > > FPConstants
SmallPtrSet< Module *, 4 > OwnedModules
OwnedModules - The set of modules instantiated in this context, and which will be automatically delet...
DenseMap< PointerType *, std::unique_ptr< ConstantPointerNull > > CPNConstants
DenseMap< Type *, std::unique_ptr< ConstantAggregateZero > > CAZConstants
DenseMap< Type *, std::unique_ptr< PoisonValue > > PVConstants
DenseMap< APInt, std::unique_ptr< ConstantInt > > IntConstants
std::vector< MDNode * > DistinctMDNodes
SyncScope::ID getOrInsertSyncScopeID(StringRef SSN)
getOrInsertSyncScopeID - Maps synchronization scope name to synchronization scope ID.
void setOptPassGate(OptPassGate &)
Set the object which can disable optional passes and individual optimizations at compile time.
VectorConstantsTy VectorConstants
DenseMap< Type *, std::unique_ptr< UndefValue > > UVConstants
OptPassGate & getOptPassGate() const
Access the object which can disable optional passes and individual optimizations at compile time.
DenseMap< const Value *, MDAttachments > ValueMetadata
Collection of metadata used in this context.
StringMapEntry< uint32_t > * getOrInsertBundleTag(StringRef Tag)
std::unique_ptr< DiagnosticHandler > DiagHandler
StringMap< uint32_t > BundleTagCache
A set of interned tags for operand bundles.
StringMap< std::unique_ptr< ConstantDataSequential > > CDSConstants
StructConstantsTy StructConstants
void getOperandBundleTags(SmallVectorImpl< StringRef > &Tags) const
FoldingSet< AttributeSetNode > AttrsSetNodes
DenseMap< TargetExtType *, std::unique_ptr< ConstantTargetNone > > CTNConstants
ConstantUniqueMap< ConstantExpr > ExprConstants
uint32_t getOperandBundleTagID(StringRef Tag) const
StringMap< SyncScope::ID > SSC
A set of interned synchronization scopes.
DenseMap< std::pair< ElementCount, APInt >, std::unique_ptr< ConstantInt > > IntSplatConstants
std::vector< ConstantRangeListAttributeImpl * > ConstantRangeListAttributes
DenseSet< DIArgList *, DIArgListInfo > DIArgLists
std::optional< StringRef > getSyncScopeName(SyncScope::ID Id) const
getSyncScopeName - Returns the name of a SyncScope::ID registered with LLVMContext,...
ArrayConstantsTy ArrayConstants
DenseMap< Value *, ValueAsMetadata * > ValuesAsMetadata
ConstantUniqueMap< InlineAsm > InlineAsms
LLVMContextImpl(LLVMContext &C)
SmallDenseMap< BasicBlock *, DbgMarker * > TrailingDbgRecords
Mapping of blocks to collections of "trailing" DbgVariableRecords.
DenseMap< std::pair< ElementCount, APFloat >, std::unique_ptr< ConstantFP > > FPSplatConstants
This is an important class for using LLVM in a threaded context.
Definition LLVMContext.h:68
static unsigned calculateHash(MDNode *N, unsigned Offset=0)
Metadata node.
Definition Metadata.h:1078
Tracking metadata reference owned by Metadata.
Definition Metadata.h:900
Root of the metadata hierarchy.
Definition Metadata.h:64
Extensions to this class implement mechanisms to disable passes and individual optimizations at compi...
Definition OptBisect.h:26
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition SmallVector.h:574
void reserve(size_type N)
Definition SmallVector.h:664
void resize(size_type N)
Definition SmallVector.h:639
void push_back(const T &Elt)
Definition SmallVector.h:417
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition SmallVector.h:1203
StringMapEntry - This is used to represent one value that is inserted into a StringMap.
StringRef - Represent a constant reference to a string, i.e.
Definition StringRef.h:55
The instances of the Type class are immutable: once they are created, they are never changed.
Definition Type.h:45
@ C
The default llvm calling convention, compatible with C.
Definition CallingConv.h:34
This is an optimization pass for GlobalISel generic memory operations.
Definition AddressRanges.h:18
auto drop_begin(T &&RangeOrContainer, size_t N=1)
Return a range covering RangeOrContainer with the first N elements excluded.
Definition STLExtras.h:316
@ Offset
Definition DWP.cpp:477
static const Metadata * get_hashable_data(const MDOperand &X)
Make MDOperand transparent for hashing.
LLVM_ABI OptPassGate & getGlobalPassGate()
Singleton instance of the OptPassGate class, so multiple pass managers don't need to coordinate their...
Definition OptBisect.cpp:94
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last)
Compute a hash_code for a sequence of values.
Definition Hashing.h:466
Implement std::hash so that hash_code can be used in STL containers.
Definition BitVector.h:867
N
#define N
This is the base class for diagnostic handling in LLVM.
Generated on for LLVM by doxygen 1.14.0

AltStyle によって変換されたページ (->オリジナル) /