Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/CodeGenAction_8cpp_source.html below:

clang: lib/CodeGen/CodeGenAction.cpp Source File

;

: CodeGenOpts(CGOpts), BackendCon(BCon) {}

[&](

LLVMRemarkSetupFileError &

) {

Diags.

(diag::err_cannot_open_file)

[&](

LLVMRemarkSetupPatternError &

) {

Diags.

(diag::err_drv_optimization_remark_pattern)

[&](

LLVMRemarkSetupFormatError &

) {

Diags.

(diag::err_drv_optimization_remark_format)

std::unique_ptr<raw_pwrite_stream> OS,

llvm::Module *CurLinkModule)

: CI(CI), Diags(CI.getDiagnostics()), CodeGenOpts(CI.getCodeGenOpts()),

TargetOpts(CI.getTargetOpts()), LangOpts(CI.getLangOpts()),

AsmOutStream(

::move(OS)), FS(VFS), Action(Action),

CI.getHeaderSearchOpts(), CI.getPreprocessorOpts(),

CI.getCodeGenOpts(),

, CoverageInfo)),

LinkModules(

::move(LinkModules)), CurLinkModule(CurLinkModule) {

TimerIsEnabled = CodeGenOpts.TimePasses;

llvm::TimePassesIsEnabled = CodeGenOpts.TimePasses;

llvm::TimePassesPerRun = CodeGenOpts.TimePassesPerRun;

(CodeGenOpts.TimePasses)

LLVMIRGeneration.init(

,

, CI.

());

Gen->GetModule();

std::unique_ptr<llvm::Module>(Gen->ReleaseModule());

Gen->HandleCXXStaticMemberVarInstantiation(VD);

assert(!Context &&

);

LLVMIRGeneration.startTimer();

Gen->Initialize(Ctx);

LLVMIRGeneration.stopTimer();

);

(TimerIsEnabled && !LLVMIRGenerationRefCount++)

Gen->HandleTopLevelDecl(

);

(TimerIsEnabled && !--LLVMIRGenerationRefCount)

);

Gen->HandleInlineFunctionDefinition(

);

(

&LM : LinkModules) {

assert(LM.Module &&

);

(LM.PropagateAttrs)

F, CodeGenOpts, LangOpts, TargetOpts, LM.Internalize);

CurLinkModule = LM.Module.get();

(LM.Internalize) {

Err = Linker::linkModules(

*M, std::move(LM.Module), LM.LinkFlags,

[](llvm::Module &M,

llvm::StringSet<> &GVS) {

internalizeModule(M, [&GVS](const llvm::GlobalValue &GV) {

return !GV.hasName() || (GVS.count(GV.getName()) == 0);

Err = Linker::linkModules(*M, std::move(LM.Module), LM.LinkFlags);

llvm::TimeTraceScope TimeScope(

);

PrettyStackTraceString CrashInfo(

);

(TimerIsEnabled && !LLVMIRGenerationRefCount++)

Gen->HandleTranslationUnit(

);

(TimerIsEnabled && !--LLVMIRGenerationRefCount)

IRGenFinished =

;

LLVMContext &Ctx =

()->getContext();

std::unique_ptr<DiagnosticHandler> OldDiagnosticHandler =

Ctx.getDiagnosticHandler();

Ctx.setDiagnosticHandler(std::make_unique<ClangDiagnosticHandler>(

CodeGenOpts,

));

Ctx.setDefaultTargetCPU(TargetOpts.

);

Ctx.setDefaultTargetFeatures(llvm::join(TargetOpts.

,

));

setupLLVMOptimizationRemarks(

(Error

= OptRecordFileOrErr.takeError()) {

std::unique_ptr<llvm::ToolOutputFile> OptRecordFile =

std::move(*OptRecordFileOrErr);

Ctx.setDiagnosticsHotnessRequested(

);

(CodeGenOpts.MisExpect) {

Ctx.setMisExpectWarningRequested(

);

Ctx.setDiagnosticsMisExpectTolerance(

(

&F :

()->functions()) {

(

*FD = Gen->GetDeclForMangledName(F.getName())) {

= FD->getASTContext().getFullLoc(FD->getLocation());

ManglingFullSourceLocs.push_back(std::make_pair(NameHash,

));

(CodeGenOpts.ClearASTBeforeBackend) {

LLVM_DEBUG(llvm::dbgs() <<

);

.getAllocator().Reset();

.getTargetInfo().getDataLayoutString(),

(),

Action, FS, std::move(AsmOutStream),

);

Ctx.setDiagnosticHandler(std::move(OldDiagnosticHandler));

OptRecordFile->keep();

);

Gen->HandleTagDeclDefinition(

);

Gen->HandleTagDeclRequiredDefinition(

);

Gen->CompleteTentativeDefinition(

);

Gen->CompleteExternalDeclaration(

);

Gen->AssignInheritanceModel(RD);

Gen->HandleVTable(RD);

BackendConsumer::anchor() { }

llvm::SourceMgr &LSM = *

.getSourceMgr();

MemoryBuffer *LBuf =

LSM.getMemoryBuffer(LSM.FindBufferContainingLoc(

.getLoc()));

std::unique_ptr<llvm::MemoryBuffer> CBuf =

llvm::MemoryBuffer::getMemBufferCopy(LBuf->getBuffer(),

LBuf->getBufferIdentifier());

Offset =

.getLoc().getPointer() - LBuf->getBufferStart();

); \

case llvm::DS_Note: \

DiagID = diag::note_fe_##GroupName; \

llvm::SMDiagnostic &

= DI.getSMDiag();

(DI.isInlineAsmDiag())

.

(

, llvm::errs());

StringRef Message =

.getMessage();

(void)Message.consume_front(

);

(

.getLoc() != SMLoc())

(DI.isInlineAsmDiag()) {

(

.getLoc().isValid()) {

(

std::pair<unsigned, unsigned> &

:

.getRanges()) {

=

.getColumnNo();

std::string Message =

.getMsgStr().str();

(

.getSeverity() != llvm::DS_Warning)

Diags.

(*

, diag::warn_fe_frame_larger_than)

<<

.getStackSize() <<

.getStackLimit()

<< llvm::demangle(

.getFunction().getName());

llvm::DiagnosticInfoResourceLimit &

) {

DiagID = diag::err_fe_backend_resource_limit;

(

.getSeverity(), backend_resource_limit, DiagID);

<<

.getResourceName() <<

.getResourceSize() <<

.getResourceLimit()

<< llvm::demangle(

.getFunction().getName());

llvm::DiagnosticInfoWithLocationBase &

,

&BadDebugInfo,

(

.isLocationAvailable()) {

(DILoc.

() &&

.isLocationAvailable())

Diags.

(

, diag::note_fe_backend_invalid_loc)

std::optional<FullSourceLoc>

(

&Pair : ManglingFullSourceLocs) {

(Pair.first == Hash)

llvm::DiagnosticInfoUnsupported &

) {

assert(

.getSeverity() == llvm::DS_Error ||

.getSeverity() == llvm::DS_Warning);

BadDebugInfo =

;

raw_string_ostream MsgStream(Msg);

(Context !=

) {

MsgStream <<

.getMessage();

DiagnosticPrinterRawOStream DP(MsgStream);

DiagType =

.getSeverity() == llvm::DS_Error

? diag::err_fe_backend_unsupported

: diag::warn_fe_backend_unsupported;

Diags.

(

, diag::note_fe_backend_invalid_loc)

llvm::DiagnosticInfoOptimizationBase &

,

DiagID) {

assert(

.getSeverity() == llvm::DS_Remark ||

.getSeverity() == llvm::DS_Warning);

BadDebugInfo =

;

raw_string_ostream MsgStream(Msg);

(Context !=

) {

MsgStream <<

.getMsg();

DiagnosticPrinterRawOStream DP(MsgStream);

(

.getHotness())

MsgStream <<

<< *

.getHotness() <<

;

Diags.

(

, diag::note_fe_backend_invalid_loc)

llvm::DiagnosticInfoOptimizationBase &

) {

(

.isVerbose() && !

.getHotness())

(

.isPassed()) {

}

(

.isMissed()) {

, diag::remark_fe_backend_optimization_remark_missed);

assert(

.isAnalysis() &&

);

ShouldAlwaysPrint =

;

(

*ORA = dyn_cast<llvm::OptimizationRemarkAnalysis>(&

))

ShouldAlwaysPrint = ORA->shouldAlwaysPrint();

(ShouldAlwaysPrint ||

, diag::remark_fe_backend_optimization_remark_analysis);

llvm::OptimizationRemarkAnalysisFPCommute &

) {

(

.shouldAlwaysPrint() ||

, diag::remark_fe_backend_optimization_remark_analysis_fpcommute);

llvm::OptimizationRemarkAnalysisAliasing &

) {

(

.shouldAlwaysPrint() ||

, diag::remark_fe_backend_optimization_remark_analysis_aliasing);

llvm::DiagnosticInfoOptimizationFailure &

) {

Diags.

(LocCookie,

.getSeverity() == DiagnosticSeverity::DS_Error

? diag::err_fe_backend_error_attr

: diag::warn_fe_backend_warning_attr)

<< llvm::demangle(

.getFunctionName()) <<

.getNote();

llvm::DiagnosticInfoMisExpect &

) {

BadDebugInfo =

;

Diags.

(

, diag::warn_profile_data_misexpect) <<

.getMsg().str();

Diags.

(

, diag::note_fe_backend_invalid_loc)

DiagID = diag::err_fe_inline_asm;

llvm::DiagnosticSeverity Severity = DI.getSeverity();

(DI.getKind()) {

llvm::DK_InlineAsm:

llvm::DK_SrcMgr:

llvm::DK_StackSize:

llvm::DK_ResourceLimit:

llvm::DK_OptimizationRemark:

llvm::DK_OptimizationRemarkMissed:

llvm::DK_OptimizationRemarkAnalysis:

llvm::DK_OptimizationRemarkAnalysisFPCommute:

llvm::DK_OptimizationRemarkAnalysisAliasing:

llvm::DK_MachineOptimizationRemark:

llvm::DK_MachineOptimizationRemarkMissed:

llvm::DK_MachineOptimizationRemarkAnalysis:

llvm::DK_OptimizationFailure:

llvm::DK_Unsupported:

llvm::DK_DontCall:

llvm::DK_MisExpect:

std::string MsgStorage;

raw_string_ostream Stream(MsgStorage);

DiagnosticPrinterRawOStream DP(Stream);

(DI.getKind() == DK_Linker) {

assert(CurLinkModule &&

);

Diags.

(DiagID) << CurLinkModule->getModuleIdentifier() << MsgStorage;

: Act(_Act), VMContext(_VMContext ? _VMContext : new LLVMContext),

OwnsVMContext(!_VMContext) {}

(!LinkModules.empty())

<< F.Filename << BCBuf.getError().message();

getOwningLazyBitcodeModule(std::move(*BCBuf), *VMContext);

handleAllErrors(ModuleOrErr.takeError(), [&](ErrorInfoBase &EIB) {

CI.getDiagnostics().Report(diag::err_cannot_open_file)

<< F.Filename << EIB.message();

LinkModules.push_back({std::move(ModuleOrErr.get()), F.PropagateAttrs,

F.Internalize, F.LinkFlags});

std::move(TheModule);

OwnsVMContext =

;

std::unique_ptr<raw_pwrite_stream>

llvm_unreachable(

);

std::unique_ptr<ASTConsumer>

(loadLinkModules(CI))

InFile, std::move(OS), CoverageInfo));

(CI.

().getDebugInfo() != codegenoptions::NoDebugInfo &&

std::unique_ptr<PPCallbacks> Callbacks =

std::vector<std::unique_ptr<ASTConsumer>> Consumers(2);

Consumers[0] = std::make_unique<ReducedBMIGenerator>(

Consumers[1] = std::move(

);

std::make_unique<MultiplexConsumer>(std::move(Consumers));

std::move(

);

std::unique_ptr<llvm::Module>

CodeGenAction::loadModule(MemoryBufferRef MBRef) {

DiagErrors = [&](Error

) -> std::unique_ptr<llvm::Module> {

handleAllErrors(std::move(

), [&](ErrorInfoBase &EIB) {

VMContext->enableDebugTypeODRUniquing();

DiagErrors(BMsOrErr.takeError());

BitcodeModule *Bm = llvm::lto::findThinLTOModule(*BMsOrErr);

M = std::make_unique<llvm::Module>(

, *VMContext);

Bm->parseModule(*VMContext);

DiagErrors(MOrErr.takeError());

std::move(*MOrErr);

(loadLinkModules(CI))

llvm::SMDiagnostic Err;

(std::unique_ptr<llvm::Module> M = parseIR(MBRef, Err, *VMContext))

(BMsOrErr && BMsOrErr->size()) {

std::unique_ptr<llvm::Module> FirstM;

(

&BM : *BMsOrErr) {

BM.parseModule(*VMContext);

DiagErrors(MOrErr.takeError());

LinkModules.push_back({std::move(*MOrErr),

,

FirstM = std::move(*MOrErr);

consumeError(BMsOrErr.takeError());

(Err.getLineNo() > 0) {

assert(Err.getColumnNo() >= 0);

=

.translateFileLineCol(

.getFileEntryForID(

.getMainFileID()),

Err.getLineNo(), Err.getColumnNo() + 1);

StringRef Msg = Err.getMessage();

Msg.consume_front(

);

std::unique_ptr<raw_pwrite_stream> OS =

std::optional<MemoryBufferRef> MainFile =

.getBufferOrNone(FID);

TheModule = loadModule(*MainFile);

(TheModule->getTargetTriple() != TargetOpts.

) {

Diagnostics.Report(

(), diag::warn_fe_override_module)

TheModule->setTargetTriple(TargetOpts.

);

(TheModule.get(), CodeGenOpts, Diagnostics);

(TheModule.get(), CodeGenOpts, *MainFile);

LLVMContext &Ctx = TheModule->getContext();

std::unique_ptr<DiagnosticHandler> PrevHandler = Ctx.getDiagnosticHandler();

~RAII() { Ctx.setDiagnosticHandler(std::move(PrevHandler)); }

std::move(LinkModules),

,

,

,

(!CodeGenOpts.LinkBitcodePostopt &&

.LinkInModules(&*TheModule))

Ctx.setDiscardValueNames(

);

Ctx.setDiagnosticHandler(

std::make_unique<ClangDiagnosticHandler>(CodeGenOpts, &

));

Ctx.setDefaultTargetCPU(TargetOpts.

);

Ctx.setDefaultTargetFeatures(llvm::join(TargetOpts.

,

));

setupLLVMOptimizationRemarks(

Ctx, CodeGenOpts.OptRecordFile, CodeGenOpts.OptRecordPasses,

CodeGenOpts.OptRecordFormat, CodeGenOpts.DiagnosticsWithHotness,

CodeGenOpts.DiagnosticsHotnessThreshold);

(Error

= OptRecordFileOrErr.takeError()) {

std::unique_ptr<llvm::ToolOutputFile> OptRecordFile =

std::move(*OptRecordFileOrErr);

OptRecordFile->keep();

EmitAssemblyAction::anchor() { }

EmitBCAction::anchor() { }

EmitLLVMAction::anchor() { }

EmitLLVMOnlyAction::anchor() { }

EmitCodeGenOnlyAction::anchor() { }

EmitObjAction::anchor() { }

Defines the clang::ASTContext interface.

#define ComputeDiagID(Severity, GroupName, DiagID)

static std::unique_ptr< raw_pwrite_stream > GetOutputStream(CompilerInstance &CI, StringRef InFile, BackendAction Action)

#define ComputeDiagRemarkID(Severity, GroupName, DiagID)

static FullSourceLoc ConvertBackendLocation(const llvm::SMDiagnostic &D, SourceManager &CSM)

ConvertBackendLocation - Convert a location in a temporary llvm::SourceMgr buffer to be a valid FullS...

Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....

Defines the clang::FileManager interface and associated types.

Defines the clang::Preprocessor interface.

Defines the SourceManager interface.

Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...

SourceManager & getSourceManager()

void ExecuteAction() override

Implement the ExecuteAction interface by running Sema on the already-initialized AST consumer.

llvm::Module * getModule() const

void CompleteExternalDeclaration(DeclaratorDecl *D) override

CompleteExternalDeclaration - Callback invoked at the end of a translation unit to notify the consume...

void OptimizationRemarkHandler(const llvm::DiagnosticInfoOptimizationBase &D)

bool StackSizeDiagHandler(const llvm::DiagnosticInfoStackSize &D)

Specialized handler for StackSize diagnostic.

void HandleVTable(CXXRecordDecl *RD) override

Callback involved at the end of a translation unit to notify the consumer that a vtable for the given...

void HandleTagDeclDefinition(TagDecl *D) override

HandleTagDeclDefinition - This callback is invoked each time a TagDecl (e.g.

bool HandleTopLevelDecl(DeclGroupRef D) override

HandleTopLevelDecl - Handle the specified top-level declaration.

void Initialize(ASTContext &Ctx) override

Initialize - This is called to initialize the consumer, providing the ASTContext.

void HandleInlineFunctionDefinition(FunctionDecl *D) override

This callback is invoked each time an inline (method or friend) function definition in a class is com...

void OptimizationFailureHandler(const llvm::DiagnosticInfoOptimizationFailure &D)

void DiagnosticHandlerImpl(const llvm::DiagnosticInfo &DI)

This function is invoked when the backend needs to report something to the user.

void HandleTagDeclRequiredDefinition(const TagDecl *D) override

This callback is invoked the first time each TagDecl is required to be complete.

void HandleInterestingDecl(DeclGroupRef D) override

HandleInterestingDecl - Handle the specified interesting declaration.

void HandleCXXStaticMemberVarInstantiation(VarDecl *VD) override

HandleCXXStaticMemberVarInstantiation - Tell the consumer that this.

std::optional< FullSourceLoc > getFunctionSourceLocation(const llvm::Function &F) const

bool ResourceLimitDiagHandler(const llvm::DiagnosticInfoResourceLimit &D)

Specialized handler for ResourceLimit diagnostic.

std::unique_ptr< llvm::Module > takeModule()

void AssignInheritanceModel(CXXRecordDecl *RD) override

Callback invoked when an MSInheritanceAttr has been attached to a CXXRecordDecl.

void HandleTranslationUnit(ASTContext &C) override

HandleTranslationUnit - This method is called when the ASTs for entire translation unit have been par...

void CompleteTentativeDefinition(VarDecl *D) override

CompleteTentativeDefinition - Callback invoked at the end of a translation unit to notify the consume...

void UnsupportedDiagHandler(const llvm::DiagnosticInfoUnsupported &D)

Specialized handler for unsupported backend feature diagnostic.

bool InlineAsmDiagHandler(const llvm::DiagnosticInfoInlineAsm &D)

Specialized handler for InlineAsm diagnostic.

bool LinkInModules(llvm::Module *M)

const FullSourceLoc getBestLocationFromDebugLoc(const llvm::DiagnosticInfoWithLocationBase &D, bool &BadDebugInfo, StringRef &Filename, unsigned &Line, unsigned &Column) const

Get the best possible source location to represent a diagnostic that may have associated debug info.

void EmitOptimizationMessage(const llvm::DiagnosticInfoOptimizationBase &D, unsigned DiagID)

Specialized handlers for optimization remarks.

void DontCallDiagHandler(const llvm::DiagnosticInfoDontCall &D)

void MisExpectDiagHandler(const llvm::DiagnosticInfoMisExpect &D)

Specialized handler for misexpect warnings.

CodeGenerator * getCodeGenerator()

void SrcMgrDiagHandler(const llvm::DiagnosticInfoSrcMgr &D)

Specialized handler for diagnostics reported using SMDiagnostic.

BackendConsumer(CompilerInstance &CI, BackendAction Action, IntrusiveRefCntPtr< llvm::vfs::FileSystem > VFS, llvm::LLVMContext &C, SmallVector< LinkModule, 4 > LinkModules, StringRef InFile, std::unique_ptr< raw_pwrite_stream > OS, CoverageSourceInfo *CoverageInfo, llvm::Module *CurLinkModule=nullptr)

Represents a C++ struct/union/class.

bool isMissedOptRemarkEnabled(StringRef PassName) const override

bool handleDiagnostics(const DiagnosticInfo &DI) override

ClangDiagnosticHandler(const CodeGenOptions &CGOpts, BackendConsumer *BCon)

bool isPassedOptRemarkEnabled(StringRef PassName) const override

bool isAnyRemarkEnabled() const override

bool isAnalysisRemarkEnabled(StringRef PassName) const override

std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override

Create the AST consumer object for this action, if supported.

CodeGenerator * getCodeGenerator() const

friend class BackendConsumer

void EndSourceFileAction() override

Callback at the end of processing a single input.

bool BeginSourceFileAction(CompilerInstance &CI) override

Callback at the start of processing a single input.

~CodeGenAction() override

CodeGenAction(unsigned _Act, llvm::LLVMContext *_VMContext=nullptr)

Create a new code generation action.

llvm::LLVMContext * takeLLVMContext()

Take the LLVM context used by this action.

BackendConsumer * BEConsumer

bool hasIRSupport() const override

Does this action support use with IR files?

void ExecuteAction() override

Callback to run the program action, using the initialized compiler instance.

std::unique_ptr< llvm::Module > takeModule()

Take the generated LLVM module, for use after the action has been run.

CodeGenOptions - Track various options which control how the code is optimized and passed to the back...

std::string OptRecordFile

The name of the file to which the backend should save YAML optimization records.

std::vector< BitcodeFileToLink > LinkBitcodeFiles

The files specified here are linked in to the module before optimizations.

std::optional< uint64_t > DiagnosticsHotnessThreshold

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

std::optional< uint32_t > DiagnosticsMisExpectTolerance

The maximum percentage profiling weights can deviate from the expected values in order to be included...

std::string OptRecordPasses

The regex that filters the passes that should be saved to the optimization records.

OptRemark OptimizationRemark

Selected optimizations for which we should enable optimization remarks.

std::string ThinLTOIndexFile

Name of the function summary index file to use for ThinLTO function importing.

OptRemark OptimizationRemarkAnalysis

Selected optimizations for which we should enable optimization analyses.

std::string OptRecordFormat

The format used for serializing remarks (default: YAML)

OptRemark OptimizationRemarkMissed

Selected optimizations for which we should enable missed optimization remarks.

static CoverageSourceInfo * setUpCoverageCallbacks(Preprocessor &PP)

The primary public interface to the Clang code generator.

CompilerInstance - Helper class for managing a single instance of the Clang compiler.

DiagnosticsEngine & getDiagnostics() const

Get the current diagnostics engine.

llvm::TimerGroup & getTimerGroup() const

std::unique_ptr< raw_pwrite_stream > createDefaultOutputFile(bool Binary=true, StringRef BaseInput="", StringRef Extension="", bool RemoveFileOnSignal=true, bool CreateMissingDirectories=false, bool ForceUseTemporary=false)

Create the default output file (from the invocation's options) and add it to the list of tracked outp...

llvm::Timer & getFrontendTimer() const

FileManager & getFileManager() const

Return the current file manager to the caller.

InMemoryModuleCache & getModuleCache() const

Preprocessor & getPreprocessor() const

Return the current preprocessor.

TargetOptions & getTargetOpts()

std::unique_ptr< llvm::raw_pwrite_stream > takeOutputStream()

FrontendOptions & getFrontendOpts()

TargetInfo & getTarget() const

llvm::vfs::FileSystem & getVirtualFileSystem() const

LangOptions & getLangOpts()

CodeGenOptions & getCodeGenOpts()

SourceManager & getSourceManager() const

Return the current source manager.

std::unique_ptr< raw_pwrite_stream > createNullOutputFile()

Stores additional source code information like skipped ranges which is required by the coverage mappi...

Decl - This represents one declaration (or definition), e.g.

SourceLocation getLocation() const

void print(raw_ostream &Out, unsigned Indentation=0, bool PrintInstantiation=false) const

Represents a ValueDecl that came out of a declarator.

A little helper class used to produce diagnostics.

Concrete class used by the front-end to report problems and issues.

DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)

Issue the message to the client.

unsigned getCustomDiagID(Level L, const char(&FormatString)[N])

Return an ID for a diagnostic with the specified format string and level.

EmitAssemblyAction(llvm::LLVMContext *_VMContext=nullptr)

EmitBCAction(llvm::LLVMContext *_VMContext=nullptr)

EmitCodeGenOnlyAction(llvm::LLVMContext *_VMContext=nullptr)

EmitLLVMAction(llvm::LLVMContext *_VMContext=nullptr)

EmitLLVMOnlyAction(llvm::LLVMContext *_VMContext=nullptr)

EmitObjAction(llvm::LLVMContext *_VMContext=nullptr)

An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...

Implements support for file system lookup, file system caching, and directory search management.

llvm::ErrorOr< std::unique_ptr< llvm::MemoryBuffer > > getBufferForFile(FileEntryRef Entry, bool isVolatile=false, bool RequiresNullTerminator=true, std::optional< int64_t > MaybeLimit=std::nullopt, bool IsText=true)

Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful,...

OptionalFileEntryRef getOptionalFileRef(StringRef Filename, bool OpenFile=false, bool CacheFailure=true)

Get a FileEntryRef if it exists, without doing anything on error.

llvm::IntrusiveRefCntPtr< llvm::vfs::FileSystem > getVirtualFileSystemPtr() const

InputKind getCurrentFileKind() const

CompilerInstance & getCompilerInstance() const

StringRef getCurrentFileOrBufferName() const

unsigned GenReducedBMI

Whether to generate reduced BMI for C++20 named modules.

std::string ModuleOutputPath

Output Path for module output file.

A SourceLocation and its associated SourceManager.

Represents a function declaration or definition.

@ CMK_ModuleInterface

Compiling a C++ modules interface unit.

void addPPCallbacks(std::unique_ptr< PPCallbacks > C)

PrettyStackTraceDecl - If a crash occurs, indicate that it happened when doing something to a specifi...

Encodes a location in the source.

static SourceLocation getFromRawEncoding(UIntTy Encoding)

Turn a raw encoding of a SourceLocation object into a real SourceLocation.

bool isValid() const

Return true if this is a valid SourceLocation object.

SourceLocation getLocWithOffset(IntTy Offset) const

Return a source location with the specified offset from this SourceLocation.

This class handles loading and caching of source files into memory.

FileID createFileID(FileEntryRef SourceFile, SourceLocation IncludePos, SrcMgr::CharacteristicKind FileCharacter, int LoadedID=0, SourceLocation::UIntTy LoadedOffset=0)

Create a new FileID that represents the specified file being #included from the specified IncludePosi...

FileManager & getFileManager() const

SourceLocation translateFileLineCol(const FileEntry *SourceFile, unsigned Line, unsigned Col) const

Get the source location for the given file:line:col triplet.

SourceLocation getLocForStartOfFile(FileID FID) const

Return the source location corresponding to the first byte of the specified file.

A trivial tuple used to represent a source range.

void AddString(StringRef V) const

Represents the declaration of a struct/union/class/enum.

const char * getDataLayoutString() const

Options for controlling the target.

std::string Triple

The name of the target triple to compile for.

std::vector< std::string > Features

The list of target specific features to enable or disable – this should be a list of strings starting...

std::string CPU

If given, the name of the target CPU to generate code for.

Represents a variable declaration or definition.

Defines the clang::TargetInfo interface.

void mergeDefaultFunctionDefinitionAttributes(llvm::Function &F, const CodeGenOptions &CodeGenOpts, const LangOptions &LangOpts, const TargetOptions &TargetOpts, bool WillInternalize)

Adds attributes to F according to our CodeGenOpts and LangOpts, as though we had emitted it ourselves...

The JSON file list parser is used to communicate input to InstallAPI.

void EmbedObject(llvm::Module *M, const CodeGenOptions &CGOpts, DiagnosticsEngine &Diags)

static void reportOptRecordError(Error E, DiagnosticsEngine &Diags, const CodeGenOptions &CodeGenOpts)

CodeGenerator * CreateLLVMCodeGen(DiagnosticsEngine &Diags, llvm::StringRef ModuleName, IntrusiveRefCntPtr< llvm::vfs::FileSystem > FS, const HeaderSearchOptions &HeaderSearchOpts, const PreprocessorOptions &PreprocessorOpts, const CodeGenOptions &CGO, llvm::LLVMContext &C, CoverageSourceInfo *CoverageInfo=nullptr)

CreateLLVMCodeGen - Create a CodeGenerator instance.

@ Result

The result type of a method or function.

void emitBackendOutput(CompilerInstance &CI, CodeGenOptions &CGOpts, StringRef TDesc, llvm::Module *M, BackendAction Action, llvm::IntrusiveRefCntPtr< llvm::vfs::FileSystem > VFS, std::unique_ptr< raw_pwrite_stream > OS, BackendConsumer *BC=nullptr)

void EmbedBitcode(llvm::Module *M, const CodeGenOptions &CGOpts, llvm::MemoryBufferRef Buf)

@ Backend_EmitAssembly

Emit native assembly files.

@ Backend_EmitLL

Emit human-readable LLVM assembly.

@ Backend_EmitBC

Emit LLVM bitcode files.

@ Backend_EmitObj

Emit native object files.

@ Backend_EmitMCNull

Run CodeGen, but don't emit anything.

@ Backend_EmitNothing

Don't emit anything (benchmarking mode)

Diagnostic wrappers for TextAPI types for error reporting.

hash_code hash_value(const clang::tooling::dependencies::ModuleID &ID)

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4