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

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

clang: lib/Tooling/DependencyScanning/DependencyScanningWorker.cpp Source File

;

tooling;

dependencies;

DependencyConsumerForwarder(std::unique_ptr<DependencyOutputOptions> Opts,

Opts(

::move(Opts)),

(

) {}

.handleDependencyOutputOpts(*Opts);

llvm::sys::path::remove_dots(CanonPath,

);

llvm::sys::fs::make_absolute(WorkingDirectory, CanonPath);

.handleFileDependency(CanonPath);

StringRef WorkingDirectory;

std::unique_ptr<DependencyOutputOptions> Opts;

(LangOpts.Modules) {

Diags->

(diag::warn_pch_vfsoverlay_mismatch);

(VFSOverlays.empty()) {

Diags->

(diag::note_pch_vfsoverlay_empty) <<

;

std::string Files = llvm::join(VFSOverlays,

);

Diags->

(diag::note_pch_vfsoverlay_files) <<

<< Files;

PrebuiltModuleListener(PrebuiltModuleFilesT &PrebuiltModuleFiles,

: PrebuiltModuleFiles(PrebuiltModuleFiles),

NewModuleFiles(NewModuleFiles),

PrebuiltModuleVFSMap(PrebuiltModuleVFSMap), ExistingHSOpts(HSOpts),

ExistingLangOpts(LangOpts), Diags(Diags) {}

(PrebuiltModuleFiles.insert({ModuleName.str(), Filename.str()}).second)

NewModuleFiles.push_back(

.str());

Complain)

{

PrebuiltModuleVFSMap.insert(

{CurrentFile, llvm::StringSet<>(VFSOverlayFiles)});

checkHeaderSearchPaths(

HSOpts, ExistingHSOpts, Complain ? &Diags :

, ExistingLangOpts);

PrebuiltModuleFilesT &PrebuiltModuleFiles;

std::string CurrentFile;

visitPrebuiltModule(StringRef PrebuiltModuleFilename,

PrebuiltModuleFilesT &ModuleFiles,

PrebuiltModuleListener Listener(ModuleFiles, Worklist, PrebuiltModuleVFSMap,

Listener.visitModuleFile(PrebuiltModuleFilename,

(!Worklist.empty()) {

std::string makeObjFileName(StringRef

) {

llvm::sys::path::replace_extension(ObjFileName,

);

std::string(ObjFileName);

deduceDepTarget(

std::string &OutputFile,

(OutputFile !=

)

(InputFiles.empty() || !InputFiles.front().isFile())

;

makeObjFileName(InputFiles.front().getFile());

DiagOpts.ShowCarets =

;

return llvm::StringSwitch<bool>(Warning)

.Cases(

,

, false)

.StartsWith(

, false)

std::optional<StringRef> getSimpleMacroName(StringRef Macro) {

StringRef Name =

.split(

).first.ltrim(

);

FinishName = [&]() -> std::optional<StringRef> {

StringRef SimpleName = Name.slice(0, I);

(SimpleName.empty())

(; I != Name.size(); ++I) {

(llvm::isAlnum(Name[I]))

MacroOpt = std::pair<StringRef, std::size_t>;

std::vector<MacroOpt> SimpleNames;

SimpleNames.reserve(PPOpts.

.size());

std::size_t Index = 0;

(

&M : PPOpts.

) {

SName = getSimpleMacroName(M.first);

SimpleNames.emplace_back(*SName, Index);

llvm::stable_sort(SimpleNames, llvm::less_first());

NewEnd = std::unique(

SimpleNames.rbegin(), SimpleNames.rend(),

[](

MacroOpt &A,

MacroOpt &B) { return A.first == B.first; });

SimpleNames.erase(SimpleNames.begin(), NewEnd.base());

(PPOpts.

) NewMacros;

NewMacros.reserve(SimpleNames.size());

(std::size_t I = 0,

= SimpleNames.size(); I !=

; ++I) {

std::size_t OriginalIndex = SimpleNames[I].second;

NewMacros.push_back(std::move(PPOpts.

[OriginalIndex]));

std::swap(PPOpts.

, NewMacros);

DependencyScanningAction(

EagerLoadModules,

DisableFree,

std::optional<StringRef> ModuleName = std::nullopt)

: WorkingDirectory(WorkingDirectory), Consumer(Consumer),

Controller(Controller), DepFS(

::move(DepFS)), Format(Format),

OptimizeArgs(OptimizeArgs), EagerLoadModules(EagerLoadModules),

DisableFree(DisableFree), ModuleName(ModuleName) {}

(std::shared_ptr<CompilerInvocation> Invocation,

std::shared_ptr<PCHContainerOperations> PCHContainerOps,

OriginalInvocation.getFrontendOpts().DisableFree = DisableFree;

(

(OptimizeArgs & ScanningOptimizations::Macros))

canonicalizeDefines(OriginalInvocation.getPreprocessorOpts());

setLastCC1Arguments(std::move(OriginalInvocation));

ScanInstanceStorage.emplace(std::move(PCHContainerOps));

DiagConsumer,

);

DiagConsumerFinisher =

llvm::make_scope_exit([DiagConsumer]() { DiagConsumer->

(); });

(OptimizeArgs & ScanningOptimizations::VFS);

StringRef ModulesCachePath =

DepFS->resetBypassedPathPrefix();

(!ModulesCachePath.empty())

DepFS->setBypassedPathPrefix(ModulesCachePath);

(llvm::ErrorOr<EntryRef> Entry =

LocalDepFS->getOrCreateFileSystemEntry(

.getName()))

(LocalDepFS->ensureDirectiveTokensArePopulated(*Entry))

Entry->getDirectiveTokens();

(visitPrebuiltModule(

Opts = std::make_unique<DependencyOutputOptions>();

(Opts->Targets.empty())

Opts->IncludeSystemHeaders =

;

ScanningOutputFormat::Make:

std::make_shared<DependencyConsumerForwarder>(

std::move(Opts), WorkingDirectory, Consumer));

ScanningOutputFormat::P1689:

ScanningOutputFormat::Full:

MDC = std::make_shared<ModuleDepCollector>(

std::move(Opts), ScanInstance, Consumer, Controller,

OriginalInvocation, std::move(PrebuiltModuleVFSMap), OptimizeArgs,

EagerLoadModules, Format == ScanningOutputFormat::P1689);

std::unique_ptr<FrontendAction> Action;

(Format == ScanningOutputFormat::P1689)

Action = std::make_unique<PreprocessOnlyAction>();

Action = std::make_unique<GetDependenciesByModuleNameAction>(*ModuleName);

Action = std::make_unique<ReadPCHAndPreprocessAction>();

DiagConsumerFinisher.release();

setLastCC1Arguments(std::move(OriginalInvocation));

hasScanned()

{

Scanned; }

std::vector<std::string> takeLastCC1Arguments() {

std::vector<std::string>

;

std::swap(Result, LastCC1Arguments);

MDC->applyDiscoveredDependencies(CI);

LastCC1Arguments = CI.getCC1CommandLine();

StringRef WorkingDirectory;

EagerLoadModules;

std::optional<StringRef> ModuleName;

std::optional<CompilerInstance> ScanInstanceStorage;

std::shared_ptr<ModuleDepCollector> MDC;

std::vector<std::string> LastCC1Arguments;

Scanned =

;

: Format(Service.getFormat()), OptimizeArgs(Service.getOptimizeArgs()),

EagerLoadModules(Service.shouldEagerLoadModules()) {

PCHContainerOps = std::make_shared<PCHContainerOperations>();

PCHContainerOps->registerReader(

std::make_unique<ObjectFilePCHContainerReader>());

PCHContainerOps->registerWriter(std::make_unique<RawPCHContainerWriter>());

FS = llvm::makeIntrusiveRefCnt<llvm::vfs::TracingFileSystem>(std::move(FS));

StringRef WorkingDirectory,

std::vector<std::string> &CommandLine,

std::optional<StringRef> ModuleName) {

std::vector<const char *> CLI;

(

std::string &Arg : CommandLine)

CLI.push_back(Arg.c_str());

sanitizeDiagOpts(*DiagOpts);

std::string DiagnosticOutput;

llvm::raw_string_ostream DiagnosticsOS(DiagnosticOutput);

DiagPrinter, ModuleName))

llvm::Error::success();

llvm::make_error<llvm::StringError>(DiagnosticsOS.str(),

llvm::inconvertibleErrorCode());

Argv.reserve(ArgStrs.size());

(

std::string &Arg : ArgStrs)

Argv.push_back(Arg.c_str());

std::unique_ptr<driver::Driver> Driver = std::make_unique<driver::Driver>(

Argv[0], llvm::sys::getDefaultTargetTriple(), Diags,

, FS);

Driver->setTitle(

);

llvm::BumpPtrAllocator Alloc;

Diags.

(diag::err_drv_expand_response_file)

<< llvm::toString(std::move(

));

std::unique_ptr<driver::Compilation> Compilation(

(Compilation->containsError())

std::vector<std::string> CommandLine, DependencyScanningAction &Action,

std::shared_ptr<clang::PCHContainerOperations> &PCHContainerOps,

std::string Executable = CommandLine[0];

(!Invocation.

())

std::vector<std::string> Args = Action.takeLastCC1Arguments();

StringRef WorkingDirectory,

std::vector<std::string> &CommandLine,

BaseFS->setCurrentWorkingDirectory(WorkingDirectory);

std::optional<std::vector<std::string>> ModifiedCommandLine;

llvm::makeIntrusiveRefCnt<llvm::vfs::OverlayFileSystem>(BaseFS);

llvm::makeIntrusiveRefCnt<llvm::vfs::InMemoryFileSystem>();

InMemoryFS->setCurrentWorkingDirectory(WorkingDirectory);

OverlayFS->pushOverlay(InMemoryFS);

ModifiedFS = OverlayFS;

llvm::sys::fs::createUniquePath(*ModuleName +

,

InMemoryFS->addFile(FakeInputPath, 0, llvm::MemoryBuffer::getMemBuffer(

));

ModifiedCommandLine = CommandLine;

ModifiedCommandLine->emplace_back(FakeInputPath);

std::vector<std::string> &FinalCommandLine =

ModifiedCommandLine ? *ModifiedCommandLine : CommandLine;

&FinalFS = ModifiedFS ? ModifiedFS : BaseFS;

std::vector<const char *> FinalCCommandLine(FinalCommandLine.size(),

);

llvm::transform(FinalCommandLine, FinalCCommandLine.begin(),

[](

std::string &Str) { return Str.c_str(); });

sanitizeDiagOpts(*DiagOpts);

Diags->setSourceManager(&SrcMgr);

DisableFree =

;

DependencyScanningAction Action(WorkingDirectory, Consumer, Controller, DepFS,

Format, OptimizeArgs, EagerLoadModules,

DisableFree, ModuleName);

(FinalCommandLine[1] ==

) {

PCHContainerOps, *Diags, Consumer);

(StringRef(

.getCreator().getName()) !=

) {

Consumer.handleBuildCommand(

{Cmd.getExecutable(),

{Cmd.getArguments().begin(), Cmd.getArguments().end()}});

std::vector<std::string> Argv;

Argv.push_back(

.getExecutable());

Argv.insert(Argv.end(),

.getArguments().begin(),

.getArguments().end());

PCHContainerOps, *Diags, Consumer);

(

&& !Action.hasScanned())

Diags->

(diag::err_fe_expected_compiler_job)

<< llvm::join(FinalCommandLine,

);

&& Action.hasScanned();

static bool forEachDriverJob(ArrayRef< std::string > ArgStrs, DiagnosticsEngine &Diags, FileManager &FM, llvm::function_ref< bool(const driver::Command &Cmd)> Callback)

static bool createAndRunToolInvocation(std::vector< std::string > CommandLine, DependencyScanningAction &Action, FileManager &FM, std::shared_ptr< clang::PCHContainerOperations > &PCHContainerOps, DiagnosticsEngine &Diags, DependencyConsumer &Consumer)

Abstract interface for callback invocations by the ASTReader.

virtual bool ReadHeaderSearchPaths(const HeaderSearchOptions &HSOpts, bool Complain)

Receives the header search paths.

virtual void visitImport(StringRef ModuleName, StringRef Filename)

If needsImportVisitation returns true, this is called for each AST file imported by this AST file.

virtual void visitModuleFile(StringRef Filename, serialization::ModuleKind Kind)

This is called for each AST file loaded.

virtual bool needsImportVisitation() const

Returns true if this ASTReaderListener wants to receive the imports of the AST file via visitImport,...

@ ARR_OutOfDate

The client can handle an AST file that cannot load because it is out-of-date relative to its input fi...

static bool readASTFileControlBlock(StringRef Filename, FileManager &FileMgr, const InMemoryModuleCache &ModuleCache, const PCHContainerReader &PCHContainerRdr, bool FindModuleFileExtensions, ASTReaderListener &Listener, bool ValidateDiagnosticOptions, unsigned ClientLoadCapabilities=ARR_ConfigurationMismatch|ARR_OutOfDate)

Read the control block for the named AST file.

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

void createSourceManager(FileManager &FileMgr)

Create the source manager and replace any existing one with it.

FileManager * createFileManager(IntrusiveRefCntPtr< llvm::vfs::FileSystem > VFS=nullptr)

Create the file manager and replace any existing one with it.

const PCHContainerReader & getPCHContainerReader() const

Return the appropriate PCHContainerReader depending on the current CodeGenOptions.

DiagnosticsEngine & getDiagnostics() const

Get the current diagnostics engine.

void createDiagnostics(llvm::vfs::FileSystem &VFS, DiagnosticConsumer *Client=nullptr, bool ShouldOwnClient=true)

Create the diagnostics engine using the invocation's diagnostic options and replace any existing one ...

void setInvocation(std::shared_ptr< CompilerInvocation > Value)

setInvocation - Replace the current invocation.

FileManager & getFileManager() const

Return the current file manager to the caller.

InMemoryModuleCache & getModuleCache() const

void addDependencyCollector(std::shared_ptr< DependencyCollector > Listener)

FrontendOptions & getFrontendOpts()

bool hasDiagnostics() const

HeaderSearchOptions & getHeaderSearchOpts()

CompilerInvocation & getInvocation()

PreprocessorOptions & getPreprocessorOpts()

bool ExecuteAction(FrontendAction &Act)

ExecuteAction - Execute the provided action against the compiler's CompilerInvocation object.

DiagnosticOptions & getDiagnosticOpts()

LangOptions & getLangOpts()

Helper class for holding the data necessary to invoke the compiler.

DependencyOutputOptions & getDependencyOutputOpts()

ArrayRef< std::string > getDependencies() const

Builds a dependency file when attached to a Preprocessor (for includes) and ASTReader (for module imp...

void finishedMainFile(DiagnosticsEngine &Diags) override

Called when the end of the main file is reached.

Abstract interface, implemented by clients of the front-end, which formats and prints fully processed...

virtual void finish()

Callback to inform the diagnostic client that processing of all source files has ended.

Options for controlling the compiler diagnostics engine.

std::vector< std::string > Warnings

The list of -W... options used to alter the diagnostic mappings, with the prefixes removed.

std::string DiagnosticSerializationFile

The file to serialize diagnostics to (non-appending).

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

DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)

Issue the message to the client.

bool hasErrorOccurred() const

DiagnosticOptions & getDiagnosticOptions() const

Retrieve the diagnostic options.

DiagnosticConsumer * getClient()

A reference to a FileEntry that includes the name of the file as it was accessed by the FileManager's...

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

void AddStats(const FileManager &Other)

Import statistics from a child FileManager and add them to this current FileManager.

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

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

Keeps track of options that affect how file operations are performed.

unsigned ModulesShareFileManager

Whether to share the FileManager when building modules.

std::string OutputFile

The output file, if any.

unsigned GenerateGlobalModuleIndex

Whether we can generate the global module index if needed.

SmallVector< FrontendInputFile, 0 > Inputs

The input files and their types.

unsigned UseGlobalModuleIndex

Whether we can use the global module index if available.

Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...

PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...

bool ModulesCheckRelocated

Perform extra checks when loading PCM files for mutable file systems.

std::string ImplicitPCHInclude

The implicit PCH included at the start of the translation unit, or empty.

bool AllowPCHWithDifferentModulesCachePath

When true, a PCH with modules cache path different to the current compilation will not be rejected.

std::vector< std::pair< std::string, bool > > Macros

std::function< std::optional< ArrayRef< dependency_directives_scan::Directive > >(FileEntryRef)> DependencyDirectivesForFile

Function for getting the dependency preprocessor directives of a file.

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

The base class of the type hierarchy.

Command - An executable path/name and argument vector to execute.

llvm::StringRef getDriverMode(StringRef ProgName, ArrayRef< const char * > Args)

Returns the driver mode option's value, i.e.

llvm::Error expandResponseFiles(SmallVectorImpl< const char * > &Args, bool ClangCLMode, llvm::BumpPtrAllocator &Alloc, llvm::vfs::FileSystem *FS=nullptr)

Expand response files from a clang driver or cc1 invocation.

bool IsClangCL(StringRef DriverMode)

Checks whether the value produced by getDriverMode is for CL mode.

ModuleKind

Specifies the kind of module that has been loaded.

@ MK_ExplicitModule

File is an explicitly-loaded module.

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

std::unique_ptr< DiagnosticOptions > CreateAndPopulateDiagOpts(ArrayRef< const char * > Argv)

@ Result

The result type of a method or function.

IntrusiveRefCntPtr< llvm::vfs::FileSystem > createVFSFromCompilerInvocation(const CompilerInvocation &CI, DiagnosticsEngine &Diags)

@ Success

Template argument deduction was successful.

int __ovld __cnfn any(char)

Returns 1 if the most significant bit in any component of x is set; otherwise returns 0.

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