LLVMContext.cpp Source File (original) (raw)

27#include

28#include

29#include

30#include

32using namespace llvm;

35 switch (BundleTagID) {

37 return "deopt";

39 return "funclet";

41 return "gc-transition";

43 return "cfguardtarget";

45 return "preallocated";

47 return "gc-live";

49 return "clang.arc.attachedcall";

51 return "ptrauth";

53 return "kcfi";

55 return "convergencectrl";

56 default:

58 }

61}

66 std::pair<unsigned, StringRef> MDKinds[] = {

67#define LLVM_FIXED_MD_KIND(EnumID, Name, Value) {EnumID, Name},

68#include "llvm/IR/FixedMetadataKinds.def"

69#undef LLVM_FIXED_MD_KIND

70 };

72 for (auto &MDKind : MDKinds) {

74 assert(ID == MDKind.first && "metadata kind id drifted");

75 (void)ID;

76 }

80 [[maybe_unused]] const auto *Entry =

82 assert(Entry->second == BundleTagID && "operand bundle id drifted!");

83 }

88 "singlethread synchronization scope ID drifted!");

89 (void)SingleThreadSSID;

94 "system synchronization scope ID drifted!");

95 (void)SystemSSID;

96}

100void LLVMContext::addModule(Module *M) {

102}

103

104void LLVMContext::removeModule(Module *M) {

107}

108

110 Module *M = F.getParent();

113}

114

115

116

117

118

121 void *DiagnosticContext, bool RespectFilters) {

125}

126

128 bool RespectFilters) {

131}

132

135}

138}

139

142}

145}

148}

151}

153 std::optional<uint32_t> Tolerance) {

155}

158}

159

162}

163

166}

169}

171 std::unique_ptrremarks::RemarkStreamer RemarkStreamer) {

173}

174

177}

180}

182 std::unique_ptr RemarkStreamer) {

183 pImpl->LLVMRS = std::move(RemarkStreamer);

184}

185

189}

190

193}

194

196{

199}

200

204}

205

208}

209

211 assert(I && "Invalid instruction");

213}

214

216

217

218

219

220

221

222

223 if (auto *Remark = dyn_cast(&DI))

224 return Remark->isEnabled() &&

225 ( Remark ->isVerbose() || Remark->getHotness());

226

227 return true;

228}

229

230const char *

232 switch (Severity) {

234 return "error";

236 return "warning";

238 return "remark";

240 return "note";

241 }

243}

244

246 if (auto *OptDiagBase = dyn_cast(&DI))

248 RS->emit(*OptDiagBase);

249

250

256 return;

257 }

258

260 return;

261

262

266 errs() << "\n";

268 exit(1);

269}

270

271

272

273

274

275

277

279 std::make_pair(

281 .first->second;

282}

283

284

285

290 Names[I->second] = I->first();

291}

292

295}

296

300}

301

304}

305

308}

309

312}

313

316}

317

320}

321

324}

325

328}

329

332}

333

335

338 return;

339

341}

342

344

347}

348

351}

352

355}

356

359}

360

363}

364

367}

368

371}

372

375}

376

379}

This file defines the StringMap class.

static bool isDiagnosticEnabled(const DiagnosticInfo &DI)

static StringRef knownBundleName(unsigned BundleTagID)

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

This file defines the SmallVector class.

This is the base abstract class for diagnostic reporting in the backend.

DiagnosticSeverity getSeverity() const

virtual void print(DiagnosticPrinter &DP) const =0

Print using the given DP a user-friendly message.

Basic diagnostic printer that uses an underlying raw_ostream.

bool DiagnosticsHotnessRequested

void getSyncScopeNames(SmallVectorImpl< StringRef > &SSNs) const

getSyncScopeNames - Populates client supplied SmallVector with synchronization scope names registered...

std::string DefaultTargetCPU

SmallPtrSet< Module *, 4 > OwnedModules

OwnedModules - The set of modules instantiated in this context, and which will be automatically delet...

std::optional< uint32_t > DiagnosticsMisExpectTolerance

The percentage of difference between profiling branch weights and llvm.expect branch weights to toler...

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.

std::unique_ptr< LLVMRemarkStreamer > LLVMRS

The specialized remark streamer used by LLVM's OptimizationRemarkEmitter.

bool DiscardValueNames

Flag to indicate if Value (other than GlobalValue) retains their name or not.

DenseMap< const Function *, std::string > GCNames

Maintain the GC name for each function.

bool RespectDiagnosticFilters

OptPassGate & getOptPassGate() const

Access the object which can disable optional passes and individual optimizations at compile time.

std::string DefaultTargetFeatures

DenseMap< Module *, unsigned > MachineFunctionNums

MachineFunctionNums - Keep the next available unique number available for a MachineFunction in given ...

StringMap< unsigned > CustomMDKindNames

CustomMDKindNames - Map to hold the metadata string to ID mapping.

StringMapEntry< uint32_t > * getOrInsertBundleTag(StringRef Tag)

std::unique_ptr< DiagnosticHandler > DiagHandler

std::unique_ptr< remarks::RemarkStreamer > MainRemarkStreamer

The main remark streamer used by all the other streamers (e.g.

void getOperandBundleTags(SmallVectorImpl< StringRef > &Tags) const

std::optional< uint64_t > DiagnosticsHotnessThreshold

The minimum hotness value a diagnostic needs in order to be included in optimization diagnostics.

uint32_t getOperandBundleTagID(StringRef Tag) const

LLVMContext::YieldCallbackTy YieldCallback

std::optional< StringRef > getSyncScopeName(SyncScope::ID Id) const

getSyncScopeName - Returns the name of a SyncScope::ID registered with LLVMContext,...

bool MisExpectWarningRequested

std::optional< DenseMap< const MDString *, DICompositeType * > > DITypeMap

This is an important class for using LLVM in a threaded context.

void setMisExpectWarningRequested(bool Requested)

std::optional< StringRef > getSyncScopeName(SyncScope::ID Id) const

getSyncScopeName - Returns the name of a SyncScope::ID registered with LLVMContext,...

remarks::RemarkStreamer * getMainRemarkStreamer()

The "main remark streamer" used by all the specialized remark streamers.

uint32_t getOperandBundleTagID(StringRef Tag) const

getOperandBundleTagID - Maps a bundle tag to an integer ID.

void disableDebugTypeODRUniquing()

void setYieldCallback(YieldCallbackTy Callback, void *OpaqueHandle)

Registers a yield callback with the given context.

void deleteGC(const Function &Fn)

Remove the GC for a function.

const std::string & getGC(const Function &Fn)

Return the GC for a function.

DiagnosticHandler::DiagnosticHandlerTy getDiagnosticHandlerCallBack() const

getDiagnosticHandlerCallBack - Return the diagnostic handler call back set by setDiagnosticHandlerCal...

void setLLVMRemarkStreamer(std::unique_ptr< LLVMRemarkStreamer > RemarkStreamer)

unsigned getMDKindID(StringRef Name) const

getMDKindID - Return a unique non-zero ID for the specified metadata kind.

void emitError(const Instruction *I, const Twine &ErrorStr)

emitError - Emit an error message to the currently installed error handler with optional location inf...

static const char * getDiagnosticMessagePrefix(DiagnosticSeverity Severity)

Get the prefix that should be printed in front of a diagnostic of the given Severity.

void enableDebugTypeODRUniquing()

std::unique_ptr< DiagnosticHandler > getDiagnosticHandler()

getDiagnosticHandler - transfers ownership of DiagnosticHandler unique_ptr to caller.

void setDefaultTargetCPU(StringRef CPU)

bool getDiagnosticsHotnessRequested() const

Return if a code hotness metric should be included in optimization diagnostics.

bool getMisExpectWarningRequested() const

void yield()

Calls the yield callback (if applicable).

void setDiagnosticsHotnessThreshold(std::optional< uint64_t > Threshold)

Set the minimum hotness value a diagnostic needs in order to be included in optimization diagnostics.

void setMainRemarkStreamer(std::unique_ptr< remarks::RemarkStreamer > MainRemarkStreamer)

bool isDiagnosticsHotnessThresholdSetFromPSI() const

Return if hotness threshold is requested from PSI.

void setOptPassGate(OptPassGate &)

Set the object which can disable optional passes and individual optimizations at compile time.

StringMapEntry< uint32_t > * getOrInsertBundleTag(StringRef TagName) const

getOrInsertBundleTag - Returns the Tag to use for an operand bundle of name TagName.

void setDiagnosticsHotnessRequested(bool Requested)

Set if a code hotness metric should be included in optimization diagnostics.

void setGC(const Function &Fn, std::string GCName)

Define the GC for a function.

bool shouldDiscardValueNames() const

Return true if the Context runtime configuration is set to discard all value names.

void(*)(LLVMContext *Context, void *OpaqueHandle) YieldCallbackTy

Defines the type of a yield callback.

bool isODRUniquingDebugTypes() const

Whether there is a string map for uniquing debug info identifiers across the context.

unsigned generateMachineFunctionNum(Function &)

generateMachineFunctionNum - Get a unique number for MachineFunction that associated with the given F...

StringRef getDefaultTargetFeatures()

Similar to {get,set}DefaultTargetCPU() but for default target-features.

void setDiagnosticsMisExpectTolerance(std::optional< uint32_t > Tolerance)

LLVMContextImpl *const pImpl

void diagnose(const DiagnosticInfo &DI)

Report a message to the currently installed diagnostic handler.

void getOperandBundleTags(SmallVectorImpl< StringRef > &Result) const

getOperandBundleTags - Populate client supplied SmallVector with the bundle tags registered in this L...

void setDiagnosticHandlerCallBack(DiagnosticHandler::DiagnosticHandlerTy DiagHandler, void *DiagContext=nullptr, bool RespectFilters=false)

setDiagnosticHandlerCallBack - This method sets a handler call back that is invoked when the backend ...

void setDiscardValueNames(bool Discard)

Set the Context runtime configuration to discard all value name (but GlobalValue).

@ OB_clang_arc_attachedcall

StringRef getDefaultTargetCPU()

Get or set the current "default" target CPU (target-cpu function attribute).

void getMDKindNames(SmallVectorImpl< StringRef > &Result) const

getMDKindNames - Populate client supplied SmallVector with the name for custom metadata IDs registere...

void * getDiagnosticContext() const

getDiagnosticContext - Return the diagnostic context set by setDiagnosticContext.

SyncScope::ID getOrInsertSyncScopeID(StringRef SSN)

getOrInsertSyncScopeID - Maps synchronization scope name to synchronization scope ID.

uint64_t getDiagnosticsHotnessThreshold() const

Return the minimum hotness value a diagnostic would need in order to be included in optimization diag...

void setDefaultTargetFeatures(StringRef Features)

const DiagnosticHandler * getDiagHandlerPtr() const

getDiagHandlerPtr - Returns const raw pointer of DiagnosticHandler set by setDiagnosticHandler.

void setDiagnosticHandler(std::unique_ptr< DiagnosticHandler > &&DH, bool RespectFilters=false)

setDiagnosticHandler - This method sets unique_ptr to object of DiagnosticHandler to provide custom d...

OptPassGate & getOptPassGate() const

Access the object which can disable optional passes and individual optimizations at compile time.

LLVMRemarkStreamer * getLLVMRemarkStreamer()

The "LLVM remark streamer" used by LLVM to serialize remark diagnostics comming from IR and MIR passe...

void getSyncScopeNames(SmallVectorImpl< StringRef > &SSNs) const

getSyncScopeNames - Populates client supplied SmallVector with synchronization scope names registered...

uint32_t getDiagnosticsMisExpectTolerance() const

A Module instance is used to store all the information related to an LLVM module.

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

bool erase(PtrType Ptr)

Remove pointer from the set.

std::pair< iterator, bool > insert(PtrType Ptr)

Inserts Ptr if and only if there is no element in the container equal to Ptr.

bool contains(ConstPtrType Ptr) const

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

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

bool insert(MapEntryTy *KeyValue)

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

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

Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...

#define llvm_unreachable(msg)

Marks that the current location is not supposed to be reachable.

@ SingleThread

Synchronized with respect to signal handlers executing in the same thread.

@ System

Synchronized with respect to all concurrently executing threads.

This is an optimization pass for GlobalISel generic memory operations.

raw_fd_ostream & errs()

This returns a reference to a raw_ostream for standard error.

DiagnosticSeverity

Defines the different supported severity of a diagnostic.

This is the base class for diagnostic handling in LLVM.

void(*)(const DiagnosticInfo *DI, void *Context) DiagnosticHandlerTy