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

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

clang: lib/Serialization/GlobalModuleIndex.cpp Source File

;

serialization;

GLOBAL_INDEX_BLOCK_ID = llvm::bitc::FIRST_APPLICATION_BLOCKID

IndexRecordTypes {

IdentifierIndexReaderTrait {

StringRef external_key_type;

StringRef internal_key_type;

hash_value_type;

offset_type;

EqualKey(

internal_key_type& a,

internal_key_type&

) {

hash_value_type

(

internal_key_type& a) {

llvm::djbHash(a);

std::pair<unsigned, unsigned>

ReadKeyDataLength(

*& d) {

llvm::support;

KeyLen = endian::readNext<uint16_t, llvm::endianness::little>(d);

DataLen = endian::readNext<uint16_t, llvm::endianness::little>(d);

std::make_pair(KeyLen, DataLen);

internal_key_type&

GetInternalKey(

external_key_type& x) {

x; }

external_key_type&

GetExternalKey(

internal_key_type& x) {

x; }

internal_key_type ReadKey(

* d,

n) {

StringRef((

*)d, n);

data_type ReadData(

internal_key_type& k,

* d,

llvm::support;

(DataLen > 0) {

ID = endian::readNext<uint32_t, llvm::endianness::little>(d);

Result.push_back(ID);

llvm::OnDiskIterableChainedHashTable<IdentifierIndexReaderTrait>

IdentifierIndexTable;

GlobalModuleIndex::GlobalModuleIndex(

std::unique_ptr<llvm::MemoryBuffer> IndexBuffer,

llvm::BitstreamCursor Cursor)

: Buffer(

::move(IndexBuffer)), IdentifierIndex(), NumIdentifierLookups(),

NumIdentifierLookupHits() {

Fail = [&](llvm::Error &&Err) {

report_fatal_error(

+ Buffer->getBufferIdentifier() +

+

(std::move(Err)));

llvm::TimeTraceScope TimeScope(

);

InGlobalIndexBlock =

;

llvm::BitstreamEntry Entry;

Fail(Res.takeError());

(Entry.Kind) {

llvm::BitstreamEntry::Error:

llvm::BitstreamEntry::EndBlock:

(InGlobalIndexBlock) {

InGlobalIndexBlock =

;

llvm::BitstreamEntry::Record:

(InGlobalIndexBlock)

llvm::BitstreamEntry::SubBlock:

(!InGlobalIndexBlock && Entry.ID == GLOBAL_INDEX_BLOCK_ID) {

(llvm::Error Err =

.EnterSubBlock(GLOBAL_INDEX_BLOCK_ID))

Fail(std::move(Err));

InGlobalIndexBlock =

;

}

(llvm::Error Err =

.SkipBlock())

Fail(std::move(Err));

(!MaybeIndexRecord)

Fail(MaybeIndexRecord.takeError());

IndexRecordTypes IndexRecord =

IndexRecordTypes

(MaybeIndexRecord.get());

(IndexRecord) {

(ID == Modules.size())

Modules.push_back(ModuleInfo());

Modules.resize(ID + 1);

Modules[

].Size =

[Idx++];

Modules[

].ModTime =

[Idx++];

Modules[

].FileName.assign(

.begin() + Idx,

NumDeps =

[Idx++];

Modules[

].Dependencies.insert(Modules[ID].Dependencies.end(),

.begin() + Idx + NumDeps);

assert(Idx ==

.size() &&

);

StringRef ModuleName = llvm::sys::path::stem(Modules[ID].

);

ModuleName = ModuleName.rsplit(

).first;

UnresolvedModules[ModuleName] =

;

IDENTIFIER_INDEX:

IdentifierIndex = IdentifierIndexTable::Create(

(

*)Blob.data() +

[0],

(

*)Blob.data() +

(uint32_t),

(

*)Blob.data(), IdentifierIndexReaderTrait());

IdentifierIndexTable *

(IdentifierIndex);

std::pair<GlobalModuleIndex *, llvm::Error>

llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> BufferOrErr =

llvm::MemoryBuffer::getFile(IndexPath.c_str());

std::make_pair(

,

llvm::errorCodeToError(BufferOrErr.getError()));

std::unique_ptr<llvm::MemoryBuffer> Buffer = std::move(BufferOrErr.get());

llvm::BitstreamCursor Cursor(*Buffer);

(

: {

,

,

,

}) {

std::make_pair(

, llvm::createStringError(std::errc::illegal_byte_sequence,

));

std::make_pair(

, Res.takeError());

std::make_pair(

(std::move(Buffer), std::move(Cursor)),

llvm::Error::success());

llvm::DenseMap<ModuleFile *, unsigned>::iterator Known

= ModulesByFile.find(

);

(Known == ModulesByFile.end())

Dependencies.clear();

(

I = 0, N = StoredDependencies.size(); I != N; ++I) {

Dependencies.push_back(MF);

(!IdentifierIndex)

++NumIdentifierLookups;

IdentifierIndexTable &Table

= *

IdentifierIndexTable *

(IdentifierIndex);

IdentifierIndexTable::iterator Known = Table.find(Name);

(Known == Table.end()) {

(

I = 0, N = ModuleIDs.size(); I != N; ++I) {

++NumIdentifierLookupHits;

StringRef Name =

->ModuleName;

llvm::StringMap<unsigned>::iterator Known = UnresolvedModules.find(Name);

(Known == UnresolvedModules.end()) {

ModuleInfo &Info = Modules[Known->second];

(

->File.getSize() == Info.Size &&

->File.getModificationTime() == Info.ModTime) {

ModulesByFile[

] = Known->second;

UnresolvedModules.erase(Known);

std::fprintf(stderr,

);

(NumIdentifierLookups) {

fprintf(stderr,

,

NumIdentifierLookupHits, NumIdentifierLookups,

(

)NumIdentifierLookupHits*100.0/NumIdentifierLookups);

std::fprintf(stderr,

);

llvm::errs() <<

;

llvm::errs() <<

;

(

&MI : Modules) {

llvm::errs() <<

<< MI.FileName <<

;

llvm::errs() <<

;

llvm::errs() <<

;

ModuleFileInfo {

ImportedModuleFileInfo {

time_t StoredModTime;

: StoredSize(Size), StoredModTime(ModTime), StoredSignature(Sig) {}

GlobalModuleIndexBuilder {

ModuleFilesMap = llvm::MapVector<FileEntryRef, ModuleFileInfo>;

ModuleFilesMap ModuleFiles;

ImportedModuleFilesMap =

std::multimap<FileEntryRef, ImportedModuleFileInfo>;

ImportedModuleFilesMap ImportedModuleFiles;

llvm::StringMap<SmallVector<unsigned, 2> > InterestingIdentifierMap;

InterestingIdentifierMap InterestingIdentifiers;

emitBlockInfoBlock(llvm::BitstreamWriter &Stream);

[It, Inserted] = ModuleFiles.try_emplace(

);

NewID = ModuleFiles.size();

GlobalModuleIndexBuilder(

: FileMgr(FileMgr), PCHContainerRdr(PCHContainerRdr) {}

writeIndex(llvm::BitstreamWriter &Stream);

llvm::BitstreamWriter &Stream,

Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETBID,

);

(!Name || Name[0] == 0)

;

.push_back(*Name++);

Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_BLOCKNAME,

);

llvm::BitstreamWriter &Stream,

.push_back(*Name++);

Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETRECORDNAME,

);

GlobalModuleIndexBuilder::emitBlockInfoBlock(llvm::BitstreamWriter &Stream) {

Stream.EnterBlockInfoBlock();

(GLOBAL_INDEX_BLOCK);

(IDENTIFIER_INDEX);

InterestingASTIdentifierLookupTrait

std::pair<StringRef, bool> data_type;

data_type ReadData(

internal_key_type& k,

* d,

llvm::support;

endian::readNext<IdentifierID, llvm::endianness::little>(d);

IsInteresting = RawID & 0x01;

std::make_pair(k, IsInteresting);

llvm::createStringError(Buffer.getError(),

);

llvm::BitstreamCursor InStream(PCHContainerRdr.

(**Buffer));

(

: {

,

,

,

})

llvm::createStringError(std::errc::illegal_byte_sequence,

);

Res.takeError();

= getModuleFileInfo(

).ID;

{

, ControlBlock, ASTBlock, DiagnosticOptionsBlock } State =

;

MaybeEntry.takeError();

llvm::BitstreamEntry Entry = MaybeEntry.get();

(Entry.Kind) {

llvm::BitstreamEntry::Error:

llvm::BitstreamEntry::Record:

(State ==

) {

Skipped.takeError();

llvm::BitstreamEntry::SubBlock:

State = ControlBlock;

(llvm::Error Err = InStream.EnterSubBlock(

))

State = DiagnosticOptionsBlock;

(llvm::Error Err = InStream.SkipBlock())

llvm::BitstreamEntry::EndBlock:

MaybeCode.takeError();

Code = MaybeCode.get();

(State == ControlBlock && Code ==

) {

Blob = Blob.substr(

[Idx++]);

off_t StoredSize = (off_t)

[Idx++];

time_t StoredModTime = (time_t)

[Idx++];

SignatureBytes.end());

Length =

[Idx++];

StringRef ImportedFile = Blob.substr(0, Length);

Blob = Blob.substr(Length);

llvm::createStringError(std::errc::bad_file_descriptor,

,

std::string(ImportedFile).c_str());

ImportedModuleFiles.insert(std::make_pair(

*DependsOnFile, ImportedModuleFileInfo(StoredSize, StoredModTime,

DependsOnID = getModuleFileInfo(*DependsOnFile).ID;

getModuleFileInfo(

).Dependencies.push_back(DependsOnID);

llvm::OnDiskIterableChainedHashTable<

InterestingASTIdentifierLookupTrait> InterestingIdentifierTable;

std::unique_ptr<InterestingIdentifierTable> Table(

InterestingIdentifierTable::Create(

(

*)Blob.data() +

[0],

(

*)Blob.data() +

(uint32_t),

(

*)Blob.data()));

(InterestingIdentifierTable::data_iterator

= Table->data_begin(),

DEnd = Table->data_end();

std::pair<StringRef, bool> Ident = *

;

InterestingIdentifiers[Ident.first].push_back(ID);

(

)InterestingIdentifiers[Ident.first];

(State == DiagnosticOptionsBlock && Code ==

) {

);

getModuleFileInfo(

).Signature = Signature;

llvm::Error::success();

IdentifierIndexWriterTrait {

StringRef key_type;

StringRef key_type_ref;

hash_value_type;

offset_type;

hash_value_type

(key_type_ref Key) {

llvm::djbHash(Key);

std::pair<unsigned,unsigned>

EmitKeyDataLength(raw_ostream& Out, key_type_ref Key, data_type_ref

) {

llvm::support;

endian::Writer

(Out, llvm::endianness::little);

KeyLen = Key.size();

DataLen =

.size() * 4;

.write<uint16_t>(KeyLen);

.write<uint16_t>(DataLen);

std::make_pair(KeyLen, DataLen);

EmitKey(raw_ostream& Out, key_type_ref Key,

KeyLen) {

Out.write(Key.data(), KeyLen);

EmitData(raw_ostream& Out, key_type_ref Key, data_type_ref

,

llvm::support;

(

I = 0, N =

.size(); I != N; ++I)

endian::write<uint32_t>(Out,

[I], llvm::endianness::little);

GlobalModuleIndexBuilder::writeIndex(llvm::BitstreamWriter &Stream) {

(

MapEntry : ImportedModuleFiles) {

= MapEntry.first;

ImportedModuleFileInfo &Info = MapEntry.second;

(getModuleFileInfo(

).Signature) {

(getModuleFileInfo(

).Signature != Info.StoredSignature)

}

(Info.StoredSize !=

.getSize() ||

Info.StoredModTime !=

.getModificationTime())

;

llvm::TimeTraceScope TimeScope(

);

Stream.Emit((

)

, 8);

Stream.Emit((

)

, 8);

Stream.Emit((

)

, 8);

Stream.Emit((

)

, 8);

emitBlockInfoBlock(Stream);

Stream.EnterSubblock(GLOBAL_INDEX_BLOCK_ID, 3);

Stream.EmitRecord(INDEX_METADATA,

);

(ModuleFilesMap::iterator M = ModuleFiles.begin(),

MEnd = ModuleFiles.end();

.push_back(M->second.ID);

.push_back(M->first.getSize());

.push_back(M->first.getModificationTime());

StringRef Name(M->first.getName());

.push_back(Name.size());

.append(Name.begin(), Name.end());

.push_back(M->second.Dependencies.size());

.append(M->second.Dependencies.begin(), M->second.Dependencies.end());

Stream.EmitRecord(MODULE,

);

llvm::OnDiskChainedHashTableGenerator<IdentifierIndexWriterTrait>

;

IdentifierIndexWriterTrait Trait;

(InterestingIdentifierMap::iterator I = InterestingIdentifiers.begin(),

IEnd = InterestingIdentifiers.end();

.insert(I->first(), I->second, Trait);

llvm::support;

endian::write<uint32_t>(Out, 0, llvm::endianness::little);

BucketOffset =

.Emit(Out, Trait);

Abbrev = std::make_shared<BitCodeAbbrev>();

Abbrev->Add(BitCodeAbbrevOp(IDENTIFIER_INDEX));

Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));

Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));

IDTableAbbrev = Stream.EmitAbbrev(std::move(Abbrev));

llvm::LockFileManager Locked(IndexPath);

llvm::LockFileManager::LFS_Error:

llvm::createStringError(std::errc::io_error,

);

llvm::LockFileManager::LFS_Owned:

llvm::LockFileManager::LFS_Shared:

llvm::createStringError(std::errc::device_or_resource_busy,

);

GlobalModuleIndexBuilder Builder(FileMgr, PCHContainerRdr);

(llvm::sys::fs::directory_iterator

(

, EC), DEnd;

(llvm::sys::path::extension(

->path()) !=

) {

(llvm::sys::path::extension(

->path()) ==

)

llvm::createStringError(std::errc::device_or_resource_busy,

);

(llvm::Error Err = Builder.loadModuleFile(*

))

llvm::BitstreamWriter OutputStream(OutputBuffer);

(Builder.writeIndex(OutputStream))

llvm::createStringError(std::errc::io_error,

);

llvm::writeToOutput(IndexPath, [&OutputBuffer](llvm::raw_ostream &OS) {

llvm::Error::success();

IdentifierIndexTable::key_iterator Current;

IdentifierIndexTable::key_iterator End;

GlobalIndexIdentifierIterator(IdentifierIndexTable &Idx) {

Current = Idx.key_begin();

StringRef Next()

{

StringRef Result = *Current;

IdentifierIndexTable &Table =

*

IdentifierIndexTable *

(IdentifierIndex);

GlobalIndexIdentifierIterator(Table);

Defines the clang::FileManager interface and associated types.

static void emitRecordID(unsigned ID, const char *Name, llvm::BitstreamWriter &Stream, SmallVectorImpl< uint64_t > &Record)

static const unsigned CurrentVersion

The global index file version.

static const char *const IndexFileName

The name of the global index file.

static void emitBlockID(unsigned ID, const char *Name, llvm::BitstreamWriter &Stream, SmallVectorImpl< uint64_t > &Record)

llvm::MachO::Record Record

static std::string toString(const clang::SanitizerSet &Sanitizers)

Produce a string containing comma-separated names of sanitizers in Sanitizers set.

#define IMPORT(DERIVED, BASE)

#define BLOCK(DERIVED, BASE)

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.

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.

A global index for a set of module files, providing information about the identifiers within those mo...

bool loadedModuleFile(ModuleFile *File)

Note that the given module file has been loaded.

void printStats()

Print statistics to standard error.

bool lookupIdentifier(llvm::StringRef Name, HitSet &Hits)

Look for all of the module files with information about the given identifier, e.g....

void getModuleDependencies(ModuleFile *File, llvm::SmallVectorImpl< ModuleFile * > &Dependencies)

Retrieve the set of module files on which the given module file directly depends.

IdentifierIterator * createIdentifierIterator() const

Returns an iterator for identifiers stored in the index table.

static std::pair< GlobalModuleIndex *, llvm::Error > readIndex(llvm::StringRef Path)

Read a global index file for the given directory.

void dump()

Print debugging view to standard error.

static llvm::Error writeIndex(FileManager &FileMgr, const PCHContainerReader &PCHContainerRdr, llvm::StringRef Path)

Write a global index into the given.

An iterator that walks over all of the known identifiers in the lookup table.

Implements an efficient mapping from strings to IdentifierInfo nodes.

This abstract interface provides operations for unwrapping containers for serialized ASTs (precompile...

virtual llvm::StringRef ExtractPCH(llvm::MemoryBufferRef Buffer) const =0

Returns the serialized AST inside the PCH container Buffer.

Information about a module that has been loaded by the ASTReader.

Base class for the trait describing the on-disk hash table for the identifiers in an AST file.

@ ModuleFileInfo

Dump information about a module file.

bool LE(InterpState &S, CodePtr OpPC)

@ AST_BLOCK_ID

The AST block, which acts as a container around the full AST block.

@ CONTROL_BLOCK_ID

The control block, which contains all of the information that needs to be validated prior to committi...

@ UNHASHED_CONTROL_BLOCK_ID

A block with unhashed content.

@ SIGNATURE

Record code for the signature that identifiers this AST file.

uint64_t IdentifierID

An ID number that refers to an identifier in an AST file.

@ IDENTIFIER_TABLE

Record code for the identifier table.

unsigned ComputeHash(Selector Sel)

std::shared_ptr< MatchComputation< T > > Generator

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

@ Other

Other implicit parameter.

Diagnostic wrappers for TextAPI types for error reporting.

The signature of a module, which is a hash of the AST content.

static constexpr size_t size

static ASTFileSignature create(std::array< uint8_t, 20 > Bytes)

static ASTFileSignature createDummy()

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