LLVMContextImpl.cpp Source File (original) (raw)

28#include

29#include

31using namespace llvm;

35 VoidTy(C, Type::VoidTyID), LabelTy(C, Type::LabelTyID),

36 HalfTy(C, Type::HalfTyID), BFloatTy(C, Type::BFloatTyID),

38 MetadataTy(C, Type::MetadataTyID), TokenTy(C, Type::TokenTyID),

39 X86_FP80Ty(C, Type::X86_FP80TyID), FP128Ty(C, Type::FP128TyID),

40 PPC_FP128Ty(C, Type::PPC_FP128TyID), X86_AMXTy(C, Type::X86_AMXTyID),

41 Int1Ty(C, 1), Int8Ty(C, 8), Int16Ty(C, 16), Int32Ty(C, 32),

42 Int64Ty(C, 64), Int128Ty(C, 128) {}

45#ifndef NDEBUG

51#endif

59#ifndef NDEBUG

62 Pair.first->dump();

64#endif

69 I->dropAllReferences();

70#define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS) \

71 for (auto *I : CLASS##s) \

72 I->dropAllReferences();

73#include "llvm/IR/Metadata.def"

77 Pair.second->dropUsers();

79 Pair.second->dropUse();

83 AL->dropAllReferences( false);

84 delete AL;

85 }

90 I->deleteAsSubclass();

93 ConstantRangeListAttribute->~ConstantRangeListAttributeImpl();

94#define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS) \

95 for (CLASS * I : CLASS##s) \

96 delete I;

97#include "llvm/IR/Metadata.def"

101 I->dropAllReferences();

103 I->dropAllReferences();

105 I->dropAllReferences();

107 I->dropAllReferences();

113

126

127

131 delete &*Elem;

132 }

133

134

135 {

141 for (auto *V : MDVs)

142 delete V;

143 }

144

145

147 delete Pair.second;

148}

149

152

153

154

155

156

158 if (C->use_empty())

160

161 while (!WorkList.empty()) {

163 if (C->use_empty()) {

164 for (const Use &Op : C->operands()) {

165 if (auto *COp = dyn_cast(Op))

166 WorkList.insert(COp);

167 }

168 C->destroyConstant();

169 }

170 }

171}

172

175}

176

177namespace llvm {

178

179

180

181

182

183

184

185

186

187

188

189

190

191

193

194}

195

198#ifndef NDEBUG

199 {

202 assert(Hash == RawHash &&

203 "Expected hash of MDOperand to equal hash of Metadata*");

204 }

205#endif

206 return Hash;

207}

208

211}

212

216}

217

221 Tags[T.second] = T.first();

222}

223

227 return I->second;

228}

229

231 auto NewSSID = SSC.size();

232 assert(NewSSID < std::numeric_limitsSyncScope::ID::max() &&

233 "Hit the maximum number of synchronization scopes allowed!");

234 return SSC.insert(std::make_pair(SSN, SyncScope::ID(NewSSID))).first->second;

235}

236

240 for (const auto &SSE : SSC)

241 SSNs[SSE.second] = SSE.first();

242}

243

244std::optional

246 for (const auto &SSE : SSC) {

247 if (SSE.second != Id)

248 continue;

249 return SSE.first();

250 }

251 return std::nullopt;

252}

253

254

255

257 if ( OPG )

259 return *OPG;

260}

261

263 this->OPG = &OPG;

264}

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...

static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")

Module.h This file contains the declarations for the Module class.

This defines the Use class.

const Type::TypeID FloatTyID

const Type::TypeID DoubleTyID

This file declares the interface for bisecting optimizations.

assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())

This file implements a set that has insertion order iteration characteristics.

static void DiagHandler(const SMDiagnostic &Diag, void *Context)

ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...

ConstantArray - Constant Array Declarations.

List of ValueAsMetadata, to be used as an argument to a dbg.value intrinsic.

This class represents an Operation in the Expression.

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 dropTriviallyDeadConstantArrays()

Destroy the ConstantArrays if they are not used.

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)

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.

LLVMContextImpl *const pImpl

static unsigned calculateHash(MDNode *N, unsigned Offset=0)

Tracking metadata reference owned by Metadata.

void dropTriviallyDeadConstantArrays()

Destroy ConstantArrays in LLVMContext if they are not used.

Extensions to this class implement mechanisms to disable passes and individual optimizations at compi...

bool empty() const

Determine if the SetVector is empty or not.

bool insert(const value_type &X)

Insert a new element into the SetVector.

value_type pop_back_val()

A SetVector that performs no allocations if smaller than a certain size.

This class consists of common code factored out of the SmallVector class to reduce code duplication b...

void reserve(size_type N)

void push_back(const T &Elt)

This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.

StringMapEntry - This is used to represent one value that is inserted into a StringMap.

iterator find(StringRef Key)

bool insert(MapEntryTy *KeyValue)

insert - Insert the specified key/value pair into the map.

StringRef - Represent a constant reference to a string, i.e.

The instances of the Type class are immutable: once they are created, they are never changed.

A Use represents the edge between a Value definition and its users.

@ C

The default llvm calling convention, compatible with C.

This is an optimization pass for GlobalISel generic memory operations.

auto drop_begin(T &&RangeOrContainer, size_t N=1)

Return a range covering RangeOrContainer with the first N elements excluded.

static const Metadata * get_hashable_data(const MDOperand &X)

Make MDOperand transparent for hashing.

OptPassGate & getGlobalPassGate()

Singleton instance of the OptBisect class, so multiple pass managers don't need to coordinate their u...

hash_code hash_combine_range(InputIteratorT first, InputIteratorT last)

Compute a hash_code for a sequence of values.

Implement std::hash so that hash_code can be used in STL containers.

This is the base class for diagnostic handling in LLVM.