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

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

clang: lib/Serialization/ASTWriter.cpp Source File

;

<

T,

Allocator>

StringRef

(

std::vector<T, Allocator> &

) {

(

.empty())

StringRef();

StringRef(

*

(&

[0]),

(

) *

.size());

<

T>

StringRef(

*

(

.data()),

(

) *

.size());

std::string

(

std::vector<bool> &

) {

Str.reserve(

.size() / 8);

(

I = 0,

=

.size(); I <

;) {

(

Bit = 0; Bit < 8 && I <

; ++Bit, ++I)

Byte |=

[I] << Bit;

llvm_unreachable(

);

llvm_unreachable(

);

AffectingModuleMaps {

llvm::DenseSet<FileID> DefinitionFileIDs;

llvm::DenseSet<const FileEntry *> DefinitionFiles;

std::optional<AffectingModuleMaps>

AffectedReason :

{

AR_TextualHeader = 0,

AR_ImportOrTextualHeader = 1,

AssignMostImportant = [](AffectedReason &LHS, AffectedReason RHS) {

LHS = std::max(LHS, RHS);

llvm::DenseMap<FileID, AffectedReason> ModuleMaps;

llvm::DenseMap<const Module *, AffectedReason> ProcessedModules;

CollectModuleMapsForHierarchy = [&](

*M,

AffectedReason Reason) {

(

[It, Inserted] = ProcessedModules.insert({M, Reason});

!Inserted && Reason <= It->second) {

std::queue<const Module *> Q;

*Mod = Q.front();

AssignMostImportant(ModuleMaps[F], Reason);

AssignMostImportant(ModuleMaps[UniqF], Reason);

CollectModuleMapsForHierarchy(RootModule, AR_ImportOrTextualHeader);

std::queue<const Module *> Q;

*CurrentModule = Q.front();

(

*ImportedModule : CurrentModule->

)

CollectModuleMapsForHierarchy(ImportedModule, AR_ImportOrTextualHeader);

CollectModuleMapsForHierarchy(UndeclaredModule, AR_ImportOrTextualHeader);

(

*M : CurrentModule->

())

(

UID = 0, LastUID = FilesByUID.size(); UID != LastUID; ++UID) {

(

*M = KH.getModule())

CollectModuleMapsForHierarchy(M, AR_TextualHeader);

llvm::DenseSet<const FileEntry *> ModuleFileEntries;

llvm::DenseSet<FileID> ModuleFileIDs;

(

[FID, Reason] : ModuleMaps) {

(Reason == AR_ImportOrTextualHeader)

ModuleFileIDs.insert(FID);

(

*FE =

.getFileEntryForID(FID))

ModuleFileEntries.insert(FE);

AffectingModuleMaps R;

R.DefinitionFileIDs = std::move(ModuleFileIDs);

R.DefinitionFiles = std::move(ModuleFileEntries);

: Writer(Writer), BasicWriter(Context, Writer,

) {}

(

.hasLocalNonFastQualifiers()) {

*typePtr =

.getTypePtr();

TypeLocWriter::VisitArrayTypeLoc(

TL) {

VisitArrayTypeLoc(TL);

VisitArrayTypeLoc(TL);

VisitArrayTypeLoc(TL);

TypeLocWriter::VisitDependentSizedArrayTypeLoc(

VisitArrayTypeLoc(TL);

TypeLocWriter::VisitDependentAddressSpaceTypeLoc(

addSourceLocation(

.getBegin());

addSourceLocation(

.getEnd());

TypeLocWriter::VisitDependentSizedExtVectorTypeLoc(

TypeLocWriter::VisitDependentVectorTypeLoc(

addSourceLocation(

.getBegin());

addSourceLocation(

.getEnd());

TypeLocWriter::VisitDependentSizedMatrixTypeLoc(

addSourceLocation(

.getBegin());

addSourceLocation(

.getEnd());

(

i = 0, e = TL.

(); i != e; ++i)

VisitFunctionTypeLoc(TL);

VisitFunctionTypeLoc(TL);

TypeLocWriter::VisitUsingTypeLoc(

TL) {

TypeLocWriter::VisitAutoTypeLoc(

TL) {

.AddConceptReference(CR);

TypeLocWriter::VisitDeducedTemplateSpecializationTypeLoc(

TypeLocWriter::VisitEnumTypeLoc(

TL) {

TypeLocWriter::VisitHLSLAttributedResourceTypeLoc(

TypeLocWriter::VisitSubstTemplateTypeParmTypeLoc(

TypeLocWriter::VisitSubstTemplateTypeParmPackTypeLoc(

TypeLocWriter::VisitTemplateSpecializationTypeLoc(

(

i = 0, e = TL.

(); i != e; ++i)

TypeLocWriter::VisitParenTypeLoc(

TL) {

TypeLocWriter::VisitDependentTemplateSpecializationTypeLoc(

(

I = 0,

= TL.

(); I !=

; ++I)

TypeLocWriter::VisitPipeTypeLoc(

TL) {

TypeLocWriter::VisitDependentBitIntTypeLoc(

ASTWriter::WriteTypeAbbrevs() {

;

std::shared_ptr<BitCodeAbbrev> Abv;

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

Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));

Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 3));

TypeExtQualAbbrev = Stream.EmitAbbrev(std::move(Abv));

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,

);

ASTWriter::WriteBlockInfoBlock() {

Stream.EnterBlockInfoBlock();

(CONTROL_BLOCK);

(OPTIONS_BLOCK);

(INPUT_FILES_BLOCK);

(SOURCE_MANAGER_BLOCK);

(PREPROCESSOR_BLOCK);

(SUBMODULE_BLOCK);

(COMMENTS_BLOCK);

(DECLTYPES_BLOCK);

(TYPE_BLOCK_POINTER);

(TYPE_LVALUE_REFERENCE);

(TYPE_RVALUE_REFERENCE);

(TYPE_MEMBER_POINTER);

(TYPE_CONSTANT_ARRAY);

(TYPE_INCOMPLETE_ARRAY);

(TYPE_VARIABLE_ARRAY);

(TYPE_EXT_VECTOR);

(TYPE_FUNCTION_NO_PROTO);

(TYPE_FUNCTION_PROTO);

(TYPE_TYPEOF_EXPR);

(TYPE_OBJC_INTERFACE);

(TYPE_OBJC_OBJECT_POINTER);

(TYPE_ELABORATED);

(TYPE_SUBST_TEMPLATE_TYPE_PARM);

(TYPE_UNRESOLVED_USING);

(TYPE_INJECTED_CLASS_NAME);

(TYPE_OBJC_OBJECT);

(TYPE_TEMPLATE_TYPE_PARM);

(TYPE_TEMPLATE_SPECIALIZATION);

(TYPE_DEPENDENT_NAME);

(TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION);

(TYPE_DEPENDENT_SIZED_ARRAY);

(TYPE_MACRO_QUALIFIED);

(TYPE_PACK_EXPANSION);

(TYPE_ATTRIBUTED);

(TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK);

(TYPE_UNARY_TRANSFORM);

(TYPE_OBJC_TYPE_PARAM);

(PREPROCESSOR_DETAIL_BLOCK);

(EXTENSION_BLOCK);

(UNHASHED_CONTROL_BLOCK);

Changed | llvm::sys::path::remove_dots(

);

assert(

&&

);

(BaseDir.empty())

(;

[Pos] && Pos < BaseDir.size(); ++Pos)

(

[Pos] != BaseDir[Pos])

(!llvm::sys::path::is_separator(

[Pos])) {

(!llvm::sys::path::is_separator(BaseDir.back()))

std::pair<ASTFileSignature, ASTFileSignature>

ASTWriter::createSignature()

{

StringRef AllBytes(Buffer.data(), Buffer.size());

Hasher.update(AllBytes.slice(ASTBlockRange.first, ASTBlockRange.second));

Hasher.update(AllBytes.slice(0, UnhashedControlBlockRange.first));

AllBytes.slice(UnhashedControlBlockRange.second, ASTBlockRange.first));

Hasher.update(AllBytes.slice(ASTBlockRange.second, StringRef::npos));

std::make_pair(ASTBlockHash, Signature);

Hasher.update(StringRef(Buffer.data(), Buffer.size()));

assert(WritingModule);

(

[ExportImported, _] : WritingModule->

)

Hasher.update(ExportImported->Signature);

(

*M : TouchedTopLevelModules)

(uint8_t Byte : S) {

Stream.BackpatchByte(BitNo, Byte);

(!WritingModule ||

std::tie(ASTBlockHash, Signature) = createSignature();

ASTWriter::writeUnhashedControlBlock(

&PP) {

;

Stream.FlushToWord();

UnhashedControlBlockRange.first = Stream.GetCurrentBitNo() >> 3;

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

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

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

Stream.EmitRecordWithBlob(ASTBlockHashAbbrev,

, Blob);

ASTBlockHashOffset = Stream.GetCurrentBitNo() - Blob.size() * 8;

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

Abbrev->Add(BitCodeAbbrevOp(

));

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

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

Stream.EmitRecordWithBlob(SignatureAbbrev,

, Blob);

SignatureOffset = Stream.GetCurrentBitNo() - Blob.size() * 8;

(!HSOpts.ModulesSkipDiagnosticOptions) {

(

I = 0, N = DiagOpts.

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

(

I = 0, N = DiagOpts.

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

(!HSOpts.ModulesSkipHeaderSearchPaths) {

.push_back(HSOpts.UserEntries.size());

(

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

.push_back(

(Entry.

));

.push_back(HSOpts.SystemHeaderPrefixes.size());

(

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

.push_back(HSOpts.SystemHeaderPrefixes[I].IsSystemHeader);

.push_back(HSOpts.VFSOverlayFiles.size());

(StringRef VFSOverlayFile : HSOpts.VFSOverlayFiles)

(!HSOpts.ModulesSkipPragmaDiagnosticMappings)

WritePragmaDiagnosticMappings(Diags,

WritingModule);

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

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

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

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

HSEntryUsage.size()};

Stream.EmitRecordWithBlob(HSUsageAbbrevCode,

,

(HSEntryUsage));

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

Abbrev->Add(BitCodeAbbrevOp(

));

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

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

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

Stream.EmitRecordWithBlob(VFSUsageAbbrevCode,

,

(VFSUsage));

UnhashedControlBlockRange.second = Stream.GetCurrentBitNo() >> 3;

ASTWriter::WriteControlBlock(

&PP, StringRef isysroot) {

;

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

MetadataAbbrev->Add(BitCodeAbbrevOp(

));

MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16));

MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16));

MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16));

MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16));

MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));

MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));

MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));

MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));

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

MetadataAbbrevCode = Stream.EmitAbbrev(std::move(MetadataAbbrev));

assert((!WritingModule || isysroot.empty()) &&

);

CLANG_VERSION_MAJOR,

CLANG_VERSION_MINOR,

ASTHasCompilerErrors};

Stream.EmitRecordWithBlob(MetadataAbbrevCode,

,

(WritingModule) {

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

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

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

Stream.EmitRecordWithBlob(AbbrevCode,

, WritingModule->

);

(WritingModule && WritingModule->

) {

BaseDir.assign(CWD->getName());

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

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

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

Stream.EmitRecordWithBlob(AbbrevCode,

, BaseDir);

BaseDirectory.assign(BaseDir.begin(), BaseDir.end());

}

(!isysroot.empty()) {

BaseDirectory = std::string(isysroot);

? Map.getModuleMapFileForUniquing(WritingModule)

->getNameAsRequested()

(

*AdditionalModMaps =

Map.getAdditionalModuleMapFiles(WritingModule)) {

.push_back(AdditionalModMaps->size());

AdditionalModMaps->end());

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

Abbrev->Add(BitCodeAbbrevOp(

));

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

Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));

Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));

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

Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));

Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));

Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));

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

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

(!M.isDirectlyImported())

.push_back(M.StandardCXXModule);

(M.StandardCXXModule) {

llvm::append_range(Blob, M.

);

Stream.EmitRecordWithBlob(AbbrevCode,

, Blob);

(

I = 0, N = TargetOpts.

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

WriteMacros = !SkipMacros;

.push_back(WriteMacros);

(

I = 0, N = PPOpts.

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

(

I = 0, N = PPOpts.

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

(

I = 0, N = PPOpts.

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

(

MainFile =

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

FileAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));

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

FileAbbrevCode = Stream.EmitAbbrev(std::move(FileAbbrev));

InputFileEntry {

BufferOverridden;

assert(IncludeFID.

() &&

);

(!IsSLocAffecting[IncludeFID.ID])

;

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

IFAbbrev->Add(BitCodeAbbrevOp(

));

IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));

IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 12));

IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 32));

IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));

IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));

IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));

IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));

IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16));

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

IFAbbrevCode = Stream.EmitAbbrev(std::move(IFAbbrev));

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

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

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

IFHAbbrevCode = Stream.EmitAbbrev(std::move(IFHAbbrev));

InputFilesOffsetBase = Stream.GetCurrentBitNo();

std::vector<InputFileEntry> UserFiles;

std::vector<InputFileEntry> SystemFiles;

assert(&SourceMgr.

(FileID::get(I)) == SLoc);

(!

->OrigEntry)

(!IsSLocFileEntryAffecting[I])

InputFileEntry Entry(*

->OrigEntry);

Entry.IsSystemFile =

(

.getFileCharacteristic());

Entry.IsTransient =

->IsTransient;

Entry.BufferOverridden =

->BufferOverridden;

Entry.IsTopLevel = IncludeFileID.

() || IncludeFileID.ID < 0 ||

!IsSLocFileEntryAffecting[IncludeFileID.ID];

MemBuff =

->getBufferIfLoaded();

ContentHash = xxh3_64bits(MemBuff->getBuffer());

<< Entry.File.getName();

Entry.ContentHash[0] =

(ContentHash);

Entry.ContentHash[1] =

(ContentHash >> 32);

(Entry.IsSystemFile)

SystemFiles.push_back(Entry);

UserFiles.push_back(Entry);

SortedFiles = llvm::concat<InputFileEntry>(std::move(UserFiles),

std::move(SystemFiles));

UserFilesNum = 0;

std::vector<uint64_t> InputFileOffsets;

(

&Entry : SortedFiles) {

&InputFileID = InputFileIDs[Entry.File];

(InputFileID != 0)

InputFileOffsets.push_back(Stream.GetCurrentBitNo() - InputFilesOffsetBase);

InputFileID = InputFileOffsets.size();

(!Entry.IsSystemFile)

(Name == NameAsRequested)

RecordData::value_type

[] = {

InputFileOffsets.size(),

Entry.BufferOverridden,

NameAsRequested.size()};

Stream.EmitRecordWithBlob(IFAbbrevCode,

,

(NameAsRequested + Name).str());

Entry.ContentHash[1]};

Stream.EmitRecordWithAbbrev(IFHAbbrevCode,

);

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

OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));

OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));

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

OffsetsAbbrevCode = Stream.EmitAbbrev(std::move(OffsetsAbbrev));

InputFileOffsets.size(), UserFilesNum};

Stream.EmitRecordWithBlob(OffsetsAbbrevCode,

,

(InputFileOffsets));

;

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

Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));

Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));

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

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

Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));

Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));

Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 24));

Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));

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

;

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

Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));

Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));

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

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

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

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

;

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

Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));

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

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

;

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

Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));

Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));

Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));

Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));

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

Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));

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

std::pair<unsigned, unsigned>

llvm::encodeULEB128(KeyLen, Out);

llvm::encodeULEB128(DataLen, Out);

std::make_pair(KeyLen, DataLen);

HeaderFileInfoTrait {

HeaderFileInfoTrait(

&Writer) : Writer(Writer) {}

key_type_ref =

key_type &;

UnresolvedModule =

llvm::PointerIntPair<Module *, 2, ModuleMap::ModuleHeaderRole>;

: HFI(HFI), AlreadyIncluded(AlreadyIncluded),

AlreadyIncluded;

data_type_ref =

data_type &;

uint8_t buf[

(key.Size) +

(key.ModTime)];

(buf, &key.Size,

(key.Size));

(buf +

(key.Size), &key.ModTime,

(key.ModTime));

llvm::xxh3_64bits(buf);

std::pair<unsigned, unsigned>

EmitKeyDataLength(raw_ostream& Out, key_type_ref key, data_type_ref

) {

KeyLen = key.Filename.size() + 1 + 8 + 8;

(

ModInfo :

.KnownHeaders)

(

.Unresolved.getPointer())

EmitKey(raw_ostream& Out, key_type_ref key,

KeyLen) {

llvm::support;

endian::Writer

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

Out.write(key.Filename.data(), KeyLen);

EmitData(raw_ostream &Out, key_type_ref key,

data_type_ref

,

DataLen) {

llvm::support;

endian::Writer

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

Start = Out.tell(); (void)Start;

Flags = (

.AlreadyIncluded << 6)

| (

.HFI.isImport << 5)

.HFI.isPragmaOnce << 4)

| (

.HFI.DirInfo << 1);

.write<uint8_t>(Flags);

(

.HFI.LazyControllingMacro.isID())

assert((

>> 3) == ModID &&

);

(

ModInfo :

.KnownHeaders)

EmitModule(ModInfo.getModule(), ModInfo.getRole());

(

.Unresolved.getPointer())

EmitModule(

.Unresolved.getPointer(),

.Unresolved.getInt());

assert(Out.tell() - Start == DataLen &&

);

ASTWriter::WriteHeaderSearch(

&HS) {

HeaderFileInfoTrait GeneratorTrait(*

);

llvm::OnDiskChainedHashTableGenerator<HeaderFileInfoTrait>

;

NumHeaderSearchEntries = 0;

(WritingModule) {

(!Worklist.empty()) {

*M = Worklist.pop_back_val();

(!

.Size || (!

.ModTime && IncludeTimestamps)) {

PP->

(

.FileNameLoc, diag::err_module_no_size_mtime_for_header)

llvm::sys::path::append(

,

.FileName);

StringRef FilenameDup = strdup(

.c_str());

SavedStrings.push_back(FilenameDup.data());

HeaderFileInfoTrait::key_type Key = {

FilenameDup, *

.Size, IncludeTimestamps ? *

.ModTime : 0};

HeaderFileInfoTrait::data_type

= {

++NumHeaderSearchEntries;

Worklist.append(SubmodulesRange.begin(), SubmodulesRange.end());

(

UID = 0, LastUID = FilesByUID.size(); UID != LastUID; ++UID) {

= StringRef(strdup(FilenameTmp.c_str()));

SavedStrings.push_back(

.data());

HeaderFileInfoTrait::key_type Key = {

HeaderFileInfoTrait::data_type

= {

++NumHeaderSearchEntries;

llvm::support;

llvm::raw_svector_ostream Out(TableData);

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

BucketOffset =

.Emit(Out, GeneratorTrait);

;

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

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

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

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

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

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

NumHeaderSearchEntries, TableData.size()};

Stream.EmitRecordWithBlob(TableAbbrev,

, TableData);

(

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

free(

*

(SavedStrings[I]));

(llvm::BitstreamWriter &Stream, StringRef Blob,

SLocBufferBlobCompressedAbbrv,

SLocBufferBlobAbbrv) {

RecordDataType = ASTWriter::RecordData::value_type;

(llvm::compression::zstd::isAvailable()) {

llvm::compression::zstd::compress(

llvm::arrayRefFromStringRef(Blob.drop_back(1)), CompressedBuffer, 9);

Stream.EmitRecordWithBlob(SLocBufferBlobCompressedAbbrv,

,

llvm::toStringRef(CompressedBuffer));

(llvm::compression::zlib::isAvailable()) {

llvm::compression::zlib::compress(

llvm::arrayRefFromStringRef(Blob.drop_back(1)), CompressedBuffer);

Stream.EmitRecordWithBlob(SLocBufferBlobCompressedAbbrv,

,

llvm::toStringRef(CompressedBuffer));

Stream.EmitRecordWithBlob(SLocBufferBlobAbbrv,

, Blob);

ASTWriter::WriteSourceManagerBlock(

&SourceMgr) {

SourceManagerBlockOffset = Stream.GetCurrentBitNo();

SLocBufferBlobCompressedAbbrv =

std::vector<uint32_t> SLocEntryOffsets;

SLocEntryOffsetsBase = Stream.GetCurrentBitNo();

FID = FileID::get(I);

Offset = Stream.GetCurrentBitNo() - SLocEntryOffsetsBase;

assert((Offset >> 32) == 0 &&

);

(

->OrigEntry) {

(!IsSLocAffecting[I])

SLocEntryOffsets.push_back(Offset);

.push_back(

.getFileCharacteristic());

.push_back(

.hasLineDirectives());

EmitBlob =

;

);

assert(InputFileIDs[*Content->

] != 0 &&

);

.push_back(getAdjustedNumCreatedFIDs(FID));

FileDeclIDsTy::iterator FDI = FileDeclIDs.find(FID);

(FDI != FileDeclIDs.end()) {

.push_back(FDI->second->FirstDeclIndex);

.push_back(FDI->second->DeclIDs.size());

Stream.EmitRecordWithAbbrev(SLocFileAbbrv,

);

std::optional<llvm::MemoryBufferRef> Buffer = Content->

(

StringRef Name = Buffer ? Buffer->getBufferIdentifier() :

;

Stream.EmitRecordWithBlob(SLocBufferAbbrv,

,

StringRef(Name.data(), Name.size() + 1));

std::optional<llvm::MemoryBufferRef> Buffer = Content->

(

Buffer = llvm::MemoryBufferRef(

,

);

StringRef Blob(Buffer->getBufferStart(), Buffer->getBufferSize() + 1);

(Stream, Blob, SLocBufferBlobCompressedAbbrv,

SLocBufferBlobAbbrv);

SLocEntryOffsets.push_back(Offset);

.push_back(getAdjustedOffset(NextOffset - SLoc->

()) - 1);

Stream.EmitRecordWithAbbrev(SLocExpansionAbbrv,

);

(SLocEntryOffsets.empty())

;

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

Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16));

Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16));

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

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

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

RecordData::value_type

[] = {

SLocEntryOffsetsBase - SourceManagerBlockOffset};

Stream.EmitRecordWithBlob(SLocOffsetsAbbrev,

,

(SLocEntryOffsets));

llvm::DenseMap<int, int> FilenameMap;

FilenameMap[-1] = -1;

(

&L : LineTable) {

(

&LE : L.second) {

(FilenameMap.insert(std::make_pair(

.FilenameID,

FilenameMap.size() - 1)).second)

(

&L : LineTable) {

.push_back(L.second.size());

(

&LE : L.second) {

.push_back(

.FileOffset);

.push_back(FilenameMap[

.FilenameID]);

.push_back((

)

.FileKind);

.push_back(

.IncludeOffset);

(MI->isBuiltinMacro())

ASTWriter::WritePreprocessor(

&PP,

IsModule) {

MacroOffsetsBase = Stream.GetCurrentBitNo();

WritePreprocessorDetail(*PPRec, MacroOffsetsBase);

(AssumeNonNullLoc.

()) {

.push_back(

);

.push_back(SkipInfo->FoundNonSkipPortion);

.push_back(SkipInfo->FoundElse);

.push_back(

);

.push_back(Cond.WasSkipping);

.push_back(Cond.FoundNonSkip);

.push_back(Cond.FoundElse);

(

.second->hadMacroDefinition() &&

(!

.second->isFromAST() ||

.second->hasChangedSinceDeserialization()))

MacroIdentifiers.push_back(

.second);

llvm::sort(MacroIdentifiers, llvm::deref<std::less<>>());

StartOffset = Stream.GetCurrentBitNo() - MacroOffsetsBase;

assert((StartOffset >> 32) == 0 &&

);

EmittedModuleMacros =

;

(

*DefMD = dyn_cast<DefMacroDirective>(MD)) {

}

(

*VisMD = dyn_cast<VisibilityMacroDirective>(MD)) {

.push_back(VisMD->isPublic());

ModuleMacroRecord.push_back(getSubmoduleID(WritingModule));

ModuleMacroRecord.clear();

EmittedModuleMacros =

;

(

*DefMD = dyn_cast<DefMacroDirective>(MD)) {

}

(

*VisMD = dyn_cast<VisibilityMacroDirective>(MD)) {

.push_back(VisMD->isPublic());

llvm::DenseMap<ModuleMacro *, unsigned> Visits;

(!Worklist.empty()) {

*

= Worklist.pop_back_val();

ModuleMacroRecord.push_back(getSubmoduleID(

->getOwningModule()));

(

*M :

->overrides())

ModuleMacroRecord.push_back(getSubmoduleID(M->getOwningModule()));

ModuleMacroRecord.clear();

(

*M :

->overrides())

(++Visits[M] == M->getNumOverridingMacros())

Worklist.push_back(M);

EmittedModuleMacros =

;

(

.empty() && !EmittedModuleMacros)

IdentMacroDirectivesOffsetMap[Name] = StartOffset;

std::vector<uint32_t> MacroOffsets;

(

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

(ID < FirstMacroID) {

assert(0 &&

);

Index =

- FirstMacroID;

(Index >= MacroOffsets.size())

MacroOffsets.resize(Index + 1);

Offset = Stream.GetCurrentBitNo() - MacroOffsetsBase;

assert((Offset >> 32) == 0 &&

);

MacroOffsets[Index] = Offset;

Stream.EmitRecord(Code,

);

(

TokNo = 0, e = MI->

(); TokNo != e; ++TokNo) {

;

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

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

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

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

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

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

MacroOffsetsBase - ASTBlockStartOffset};

Stream.EmitRecordWithBlob(MacroOffsetAbbrev,

,

(MacroOffsets));

uint64_t MacroOffsetsBase) {

NumPreprocessingRecords = 0;

;

InclusionAbbrev = 0;

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

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

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

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

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

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

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

FirstPreprocessorEntityID

= (Chain ? PPRec.getNumLoadedPreprocessedEntities() : 0)

NextPreprocessorEntityID = FirstPreprocessorEntityID;

(void)++

, ++NumPreprocessingRecords, ++NextPreprocessorEntityID) {

Offset = Stream.GetCurrentBitNo() - MacroOffsetsBase;

assert((Offset >> 32) == 0 &&

);

R = getAdjustedRange((*E)->getSourceRange());

PreprocessedEntityOffsets.emplace_back(

(

*MD = dyn_cast<MacroDefinitionRecord>(*

)) {

MacroDefinitions[MD] = NextPreprocessorEntityID;

(

*ME = dyn_cast<MacroExpansion>(*

)) {

.push_back(ME->isBuiltinMacro());

(ME->isBuiltinMacro())

.push_back(MacroDefinitions[ME->getDefinition()]);

(

*ID = dyn_cast<InclusionDirective>(*

)) {

.push_back(

->getFileName().size());

.push_back(

->wasInQuotes());

.push_back(

(

->getKind()));

.push_back(

->importedModule());

Buffer +=

->getFileName();

(

->getFile())

Buffer +=

->getFile()->getName();

Stream.EmitRecordWithBlob(InclusionAbbrev,

, Buffer);

llvm_unreachable(

);

(NumPreprocessingRecords > 0) {

assert(PreprocessedEntityOffsets.size() == NumPreprocessingRecords);

;

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

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

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

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

FirstPreprocessorEntityID -

Stream.EmitRecordWithBlob(PPEOffsetAbbrev,

,

(PreprocessedEntityOffsets));

(SkippedRanges.size() > 0) {

std::vector<PPSkippedRange> SerializedSkippedRanges;

SerializedSkippedRanges.reserve(SkippedRanges.size());

(

&

: SkippedRanges)

SerializedSkippedRanges.emplace_back(

;

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

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

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

Stream.EmitRecordWithBlob(PPESkippedRangeAbbrev,

,

(SerializedSkippedRanges));

Known = SubmoduleIDs.find(Mod);

(Known != SubmoduleIDs.end())

Known->second;

(Top != WritingModule &&

!Top->fullModuleNameIs(StringRef(

().CurrentModule))))

SubmoduleIDs[Mod] = NextSubmoduleID++;

ASTWriter::getSubmoduleID(

*Mod) {

ChildModules = 0;

ChildModules + 1;

ASTWriter::WriteSubmodules(

*WritingModule,

*Context) {

;

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

Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));

Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));

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

Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));

Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4));

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));

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

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

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

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

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

RecordData::value_type

[] = {

std::queue<Module *> Q;

Q.push(WritingModule);

(!Q.empty()) {

= getSubmoduleID(Mod);

assert(SubmoduleIDs[Mod->

] &&

);

ParentID = SubmoduleIDs[Mod->

];

UnadjustedInferredFID;

InferredFID = getAdjustedFileID(UnadjustedInferredFID).getOpaqueValue();

(RecordData::value_type)Mod->

,

(RecordData::value_type)InferredFID,

Stream.EmitRecordWithBlob(DefinitionAbbrev,

, Mod->

);

Stream.EmitRecordWithBlob(RequiresAbbrev,

, R.FeatureName);

(std::optional<Module::Header> UmbrellaHeader =

Stream.EmitRecordWithBlob(UmbrellaAbbrev,

,

UmbrellaHeader->NameAsWritten);

}

(std::optional<Module::DirectoryName> UmbrellaDir =

Stream.EmitRecordWithBlob(UmbrellaDirAbbrev,

,

UmbrellaDir->NameAsWritten);

RecordKind;

(

&HL : HeaderLists) {

RecordData::value_type

[] = {HL.RecordKind};

(

&H : Mod->

(HL.HeaderKind))

Stream.EmitRecordWithBlob(HL.Abbrev,

, H.NameAsWritten);

Stream.EmitRecordWithBlob(TopHeaderAbbrev,

, HeaderName);

(!Mod->

.empty()) {

(

*I : Mod->

)

.push_back(getSubmoduleID(I));

.push_back(getSubmoduleID(I));

(!Mod->

.empty()) {

(

&

: Mod->

) {

.push_back(getSubmoduleID(

.getPointer()));

.push_back(

.getInt());

Stream.EmitRecordWithBlob(LinkLibraryAbbrev,

, LL.Library);

getSubmoduleID(

.Other)};

Stream.EmitRecordWithBlob(ConflictAbbrev,

,

.Message);

Stream.EmitRecordWithBlob(ConfigMacroAbbrev,

, CM);

assert((NextSubmoduleID - FirstSubmoduleID ==

);

llvm::SmallDenseMap<const DiagnosticsEngine::DiagState *, unsigned, 64>

CurrID = 0;

EncodeDiagStateFlags =

[](

DiagnosticsEngine::DiagState *DS) ->

{

(

Val :

{(

)DS->IgnoreAllWarnings, (

)DS->EnableAllWarnings,

(

)DS->WarningsAsErrors, (

)DS->ErrorsAsFatal,

(

)DS->SuppressSystemWarnings})

Flags = EncodeDiagStateFlags(

.DiagStatesByLoc.FirstDiagState);

.push_back(Flags);

AddDiagState = [&](

DiagnosticsEngine::DiagState *State,

IncludeNonPragmaStates) {

assert(Flags == EncodeDiagStateFlags(State) &&

);

assert(!IncludeNonPragmaStates ||

State ==

.DiagStatesByLoc.FirstDiagState);

&DiagStateID = DiagStateIDMap[State];

.push_back(DiagStateID);

(DiagStateID == 0) {

DiagStateID = ++CurrID;

SizeIdx =

.size();

(

&I : *State) {

(!I.second.isPragma() && !IncludeNonPragmaStates)

(!I.second.isPragma() &&

I.second ==

.getDiagnosticIDs()->getDefaultMapping(I.first))

Mappings.push_back(I);

llvm::sort(Mappings, llvm::less_first());

(

&I : Mappings) {

.push_back(I.first);

.push_back(I.second.serialize());

AddDiagState(

.DiagStatesByLoc.FirstDiagState, isModule);

NumLocationsIdx =

.size();

NumLocations = 0;

(

&FileIDAndFile :

.DiagStatesByLoc.Files) {

(!FileIDAndFile.first.isValid() ||

!FileIDAndFile.second.HasLocalTransitions)

.push_back(FileIDAndFile.second.StateTransitions.size());

(

&StatePoint : FileIDAndFile.second.StateTransitions) {

.push_back(getAdjustedOffset(StatePoint.Offset));

AddDiagState(StatePoint.State,

);

[NumLocationsIdx] = NumLocations;

AddDiagState(

.DiagStatesByLoc.CurDiagState,

);

IdxRef =

(0, NextTypeID++);

assert(Idx.

() >= FirstTypeID &&

);

ASTTypeWriter(Context, *

).write(

) - DeclTypesBlockStartOffset;

(TypeOffsets.size() == Index)

TypeOffsets.emplace_back(Offset);

(TypeOffsets.size() < Index) {

TypeOffsets.resize(Index + 1);

TypeOffsets[Index].set(Offset);

llvm_unreachable(

);

*ND = dyn_cast<NamedDecl>(

);

Offset = Stream.GetCurrentBitNo();

(

*

: DC->

()) {

KindDeclPairs.push_back(

->

());

KindDeclPairs.push_back(

(

).getRawValue());

++NumLexicalDeclContexts;

Stream.EmitRecordWithBlob(DeclContextLexicalAbbrev,

,

(KindDeclPairs));

ASTWriter::WriteTypeDeclOffsets() {

;

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

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

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

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

Stream.EmitRecordWithBlob(TypeOffsetAbbrev,

,

(TypeOffsets));

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

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

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

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

Stream.EmitRecordWithBlob(DeclOffsetAbbrev,

,

(DeclOffsets));

ASTWriter::WriteFileDeclIDsMap() {

;

SortedFileDeclIDs.reserve(FileDeclIDs.size());

(

&

: FileDeclIDs)

SortedFileDeclIDs.push_back(std::make_pair(

.first,

.second.get()));

llvm::sort(SortedFileDeclIDs, llvm::less_first());

(

&FileDeclEntry : SortedFileDeclIDs) {

DeclIDInFileInfo &Info = *FileDeclEntry.second;

Info.FirstDeclIndex = FileGroupedDeclIDs.size();

llvm::stable_sort(Info.DeclIDs);

(

&LocDeclEntry : Info.DeclIDs)

FileGroupedDeclIDs.push_back(LocDeclEntry.second.getRawValue());

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

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

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

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

FileGroupedDeclIDs.size()};

Stream.EmitRecordWithBlob(AbbrevCode,

,

(FileGroupedDeclIDs));

ASTWriter::WriteComments(

&Context) {

_ = llvm::make_scope_exit([

] { Stream.ExitBlock(); });

(

&FO : Context.

.OrderedComments) {

(

&OC : FO.second) {

ASTMethodPoolTrait {

key_type_ref = key_type;

data_type_ref =

data_type &;

ASTMethodPoolTrait(

&Writer) : Writer(Writer) {}

std::pair<unsigned, unsigned>

EmitKeyDataLength(raw_ostream& Out,

Sel,

data_type_ref Methods) {

DataLen = 4 + 2 + 2;

(ShouldWriteMethodListNode(Method))

DataLen +=

(

);

(ShouldWriteMethodListNode(Method))

DataLen +=

(

);

EmitKey(raw_ostream& Out,

Sel,

) {

llvm::support;

endian::Writer

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

assert((Start >> 32) == 0 &&

);

.write<uint16_t>(N);

(

I = 0; I != N; ++I)

EmitData(raw_ostream& Out, key_type_ref,

data_type_ref Methods,

DataLen) {

llvm::support;

endian::Writer

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

Start = Out.tell(); (void)Start;

NumInstanceMethods = 0;

(ShouldWriteMethodListNode(Method))

++NumInstanceMethods;

NumFactoryMethods = 0;

(ShouldWriteMethodListNode(Method))

++NumFactoryMethods;

InstanceBits = Methods.Instance.getBits();

assert(InstanceBits < 4);

InstanceHasMoreThanOneDeclBit =

Methods.Instance.hasMoreThanOneDecl();

FullInstanceBits = (NumInstanceMethods << 3) |

(InstanceHasMoreThanOneDeclBit << 2) |

FactoryBits = Methods.Factory.getBits();

assert(FactoryBits < 4);

FactoryHasMoreThanOneDeclBit =

Methods.Factory.hasMoreThanOneDecl();

FullFactoryBits = (NumFactoryMethods << 3) |

(FactoryHasMoreThanOneDeclBit << 2) |

.write<uint16_t>(FullInstanceBits);

.write<uint16_t>(FullFactoryBits);

(ShouldWriteMethodListNode(Method))

(ShouldWriteMethodListNode(Method))

assert(Out.tell() - Start == DataLen &&

);

(

->getMethod() && !

->getMethod()->isFromASTFile());

ASTWriter::WriteSelectors(

&SemaRef) {

;

(SemaRef.

().

.empty() && SelectorIDs.empty())

NumTableEntries = 0;

llvm::OnDiskChainedHashTableGenerator<ASTMethodPoolTrait>

;

ASTMethodPoolTrait Trait(*

);

SelectorOffsets.resize(NextSelectorID - FirstSelectorID);

(

&SelectorAndID : SelectorIDs) {

SemaObjC::GlobalMethodPool::iterator F =

ASTMethodPoolTrait::data_type

= {

.Instance = F->second.first;

.Factory = F->second.second;

(Chain && ID < FirstSelectorID) {

changed =

;

(!M->getMethod()->isFromASTFile()) {

.Instance = *M;

(!M->getMethod()->isFromASTFile()) {

}

(

.Instance.getMethod() ||

.Factory.getMethod()) {

llvm::support;

ASTMethodPoolTrait Trait(*

);

llvm::raw_svector_ostream Out(MethodPool);

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

BucketOffset =

.Emit(Out, Trait);

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

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

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

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

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

Stream.EmitRecordWithBlob(MethodPoolAbbrev,

, MethodPool);

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

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

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

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

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

RecordData::value_type

[] = {

Stream.EmitRecordWithBlob(SelectorOffsetAbbrev,

,

(SelectorOffsets));

ASTWriter::WriteReferencedSelectorsPool(

&SemaRef) {

;

Sel = SelectorAndLocation.first;

Writer.AddSelectorRef(Sel);

(; Redecl; Redecl = Redecl->getPreviousDecl()) {

(!Redecl->isFromASTFile()) {

(!Redecl->getDeclContext()->getRedeclContext()->Equals(

cast<NamedDecl>(Redecl);

(Redecl->getOwningModuleID() == 0)

(!

->isFromASTFile())

cast<NamedDecl>(

);

IsInterestingIdentifier(

*II, uint64_t MacroOffset,

IsModule,

IsCPlusPlus) {

NeedDecls = !IsModule || !IsCPlusPlus;

IsInteresting =

(MacroOffset || II->

() || (!IsModule && IsInteresting) ||

IsCPlusPlus = Writer.

().CPlusPlus;

IsInterestingIdentifier(II,

0, IsModule, IsCPlusPlus);

ASTIdentifierTableTrait {

IsInterestingIdentifier(II, MacroOffset, IsModule,

key_type_ref = key_type;

data_type_ref = data_type;

: Writer(Writer), PP(PP), IdResolver(IdResolver), IsModule(IsModule),

NeedDecls(!IsModule || !Writer.getLangOpts().

),

InterestingIdentifierOffsets(InterestingIdentifierOffsets) {}

needDecls()

{

NeedDecls; }

llvm::djbHash(II->

());

std::pair<unsigned, unsigned>

(InterestingIdentifierOffsets &&

InterestingIdentifierOffsets->push_back(Out.tell());

KeyLen = II->

() + 1;

(NeedDecls && IdResolver)

DataLen += std::distance(IdResolver->

(II), IdResolver->

()) *

EmitKey(raw_ostream &Out,

*II,

KeyLen) {

llvm::support;

endian::Writer

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

assert((Bits & 0xffff) == Bits &&

);

.write<uint16_t>(Bits);

HadMacroDefinition = MacroOffset != 0;

Bits = (Bits << 1) |

(HadMacroDefinition);

Bits = (Bits << 1) |

(II->

());

.write<uint16_t>(Bits);

(HadMacroDefinition)

(NeedDecls && IdResolver) {

;

llvm::OnDiskChainedHashTableGenerator<ASTIdentifierTableTrait>

;

ASTIdentifierTableTrait Trait(*

, PP, IdResolver, IsModule,

IsModule ? &InterestingIdents :

);

IdentifierOffsets.resize(NextIdentID - FirstIdentID);

(

IdentIDPair : IdentifierIDs) {

assert(II &&

);

(Trait.needDecls() &&

llvm::support;

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

BucketOffset =

.Emit(Out, Trait);

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

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

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

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

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

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

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

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

(

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

assert(IdentifierOffsets[I] &&

);

IdentifierOffsets.size()};

Stream.EmitRecordWithBlob(IdentifierOffsetAbbrev,

,

(IdentifierOffsets));

(!InterestingIdents.empty())

PendingEmittingVTables.push_back(RD);

ASTDeclContextNameLookupTraitBase {

data_type = std::pair<unsigned, unsigned>;

data_type_ref =

data_type &;

ASTDeclContextNameLookupTraitBase(

&Writer)

data_type getData(

DeclIDsTy &LocalIDs) {

Start = DeclIDs.size();

(

: LocalIDs)

DeclIDs.push_back(

);

std::make_pair(Start, DeclIDs.size());

Start = DeclIDs.size();

std::make_pair(Start, DeclIDs.size());

EmitFileRef(raw_ostream &Out,

*F)

{

);

llvm::support;

llvm::endianness::little);

std::pair<unsigned, unsigned> EmitKeyDataLengthBase(raw_ostream &Out,

data_type_ref Lookup) {

KeyLen = 1;

(Name.getKind()) {

DataLen =

(

) * (Lookup.second - Lookup.first);

{KeyLen, DataLen};

llvm::support;

endian::Writer

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

.write<uint8_t>(Name.getKind());

(Name.getKind()) {

);

.write<uint8_t>(Name.getOperatorKind());

llvm_unreachable(

);

EmitDataBase(raw_ostream &Out, data_type Lookup,

DataLen) {

llvm::support;

endian::Writer

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

Start = Out.tell(); (void)Start;

(

I = Lookup.first, N = Lookup.second; I != N; ++I)

assert(Out.tell() - Start == DataLen &&

);

ModuleLevelNameLookupTrait :

ASTDeclContextNameLookupTraitBase {

primary_module_hash_type =

;

key_type = std::pair<DeclarationNameKey, primary_module_hash_type>;

key_type_ref = key_type;

ModuleLevelNameLookupTrait(

&Writer)

: ASTDeclContextNameLookupTraitBase(Writer) {}

EqualKey(key_type_ref a, key_type_ref

) {

a ==

; }

llvm::FoldingSetNodeID

;

.AddInteger(Key.first.getHash());

.AddInteger(Key.second);

.computeStableHash();

std::pair<unsigned, unsigned>

EmitKeyDataLength(raw_ostream &Out, key_type Key, data_type_ref Lookup) {

[KeyLen, DataLen] = EmitKeyDataLengthBase(Out, Key.first, Lookup);

KeyLen +=

(Key.second);

EmitKey(raw_ostream &Out, key_type Key,

) {

EmitKeyBase(Out, Key.first);

llvm::support::endian::Writer

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

.write<primary_module_hash_type>(Key.second);

EmitData(raw_ostream &Out, key_type_ref, data_type Lookup,

EmitDataBase(Out, Lookup, DataLen);

isModuleLocalDecl(

*

) {

isModuleLocalDecl(

);

(

*FTD = dyn_cast<FunctionTemplateDecl>(

))

(

*CDGD = dyn_cast<CXXDeductionGuideDecl>(FTD->getTemplatedDecl()))

isModuleLocalDecl(CDGD->getDeducedTemplate());

isTULocalInNamedModules(

*

) {

<

CollectingTULocalDecls>

ASTDeclContextNameLookupTrait :

ASTDeclContextNameLookupTraitBase {

ModuleLevelDeclsMapTy =

llvm::DenseMap<ModuleLevelNameLookupTrait::key_type, DeclIDsTy>;

key_type_ref = key_type;

TULocalDeclsMapTy = llvm::DenseMap<key_type, DeclIDsTy>;

ModuleLevelDeclsMapTy ModuleLocalDeclsMap;

TULocalDeclsMapTy TULocalDeclsMap;

ASTDeclContextNameLookupTrait(

&Writer)

: ASTDeclContextNameLookupTraitBase(Writer) {}

<

Coll> data_type getData(

Coll &Decls) {

Start = DeclIDs.size();

(isModuleLocalDecl(

)) {

(std::optional<unsigned> PrimaryModuleHash =

Key = std::make_pair(

->getDeclName(), *PrimaryModuleHash);

= ModuleLocalDeclsMap.find(Key);

(

== ModuleLocalDeclsMap.end())

ModuleLocalDeclsMap.insert({Key, DeclIDsTy{

}});

->second.push_back(

);

(CollectingTULocalDecls) {

(isTULocalInNamedModules(

)) {

= TULocalDeclsMap.find(

->getDeclName());

(

== TULocalDeclsMap.end())

TULocalDeclsMap.insert({

->getDeclName(), DeclIDsTy{

}});

->second.push_back(

);

DeclIDs.push_back(

);

std::make_pair(Start, DeclIDs.size());

ASTDeclContextNameLookupTraitBase::getData;

ModuleLevelDeclsMapTy &getModuleLocalDecls() {

ModuleLocalDeclsMap;

TULocalDeclsMapTy &getTULocalDecls() {

TULocalDeclsMap; }

EqualKey(key_type_ref a, key_type_ref

) {

a ==

; }

hash_value_type

(key_type Name) {

Name.getHash(); }

std::pair<unsigned, unsigned> EmitKeyDataLength(raw_ostream &Out,

data_type_ref Lookup) {

[KeyLen, DataLen] = EmitKeyDataLengthBase(Out, Name, Lookup);

EmitKeyBase(Out, Name);

EmitData(raw_ostream &Out, key_type_ref, data_type Lookup,

EmitDataBase(Out, Lookup, DataLen);

LazySpecializationInfoLookupTrait {

key_type_ref = key_type;

data_type = std::pair<unsigned, unsigned>;

data_type_ref =

data_type &;

LazySpecializationInfoLookupTrait(

&Writer)

<

Col,

Col2>

data_type getData(Col &&

, Col2 &ExistingInfo) {

Start = Specs.size();

(

*

:

) {

Specs.push_back(Info);

std::make_pair(Start, Specs.size());

data_type ImportData(

Start = Specs.size();

(

: FromReader)

Specs.push_back(

);

std::make_pair(Start, Specs.size());

EqualKey(key_type_ref a, key_type_ref

) {

a ==

; }

hash_value_type

(key_type Name) {

Name; }

EmitFileRef(raw_ostream &Out,

*F)

{

);

llvm::support;

llvm::endianness::little);

std::pair<unsigned, unsigned> EmitKeyDataLength(raw_ostream &Out,

data_type_ref Lookup) {

KeyLen = 4;

(Lookup.second - Lookup.first);

EmitKey(raw_ostream &Out, key_type HashValue,

) {

llvm::support;

endian::Writer

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

EmitData(raw_ostream &Out, key_type_ref, data_type Lookup,

llvm::support;

endian::Writer

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

(

I = Lookup.first, N = Lookup.second; I != N; ++I) {

.write<

>(Specs[I].getRawValue());

assert(Out.tell() - Start == DataLen &&

);

CalculateODRHashForSpecs(

*Spec) {

(

*CTSD = dyn_cast<ClassTemplateSpecializationDecl>(Spec))

Args = CTSD->getTemplateArgs().asArray();

(

*VTSD = dyn_cast<VarTemplateSpecializationDecl>(Spec))

Args = VTSD->getTemplateArgs().asArray();

(

*FD = dyn_cast<FunctionDecl>(Spec))

Args = FD->getTemplateSpecializationArgs()->asArray();

llvm_unreachable(

);

ASTWriter::GenerateSpecializationInfoLookupTable(

LazySpecializationInfoLookupTrait>

LazySpecializationInfoLookupTrait Trait(*

);

llvm::DenseMap<unsigned, llvm::SmallVector<const NamedDecl *, 4>>

HashedValue = CalculateODRHashForSpecs(

);

= SpecializationMaps.find(HashedValue);

(

== SpecializationMaps.end())

= SpecializationMaps

.try_emplace(HashedValue,

(

&[HashValue, Specs] : SpecializationMaps) {

ExisitingSpecs = Lookups->Table.find(HashValue);

.insert(HashValue, Trait.getData(Specs, ExisitingSpecs), Trait);

.emit(LookupTable, Trait, Lookups ? &Lookups->Table :

);

ASTWriter::WriteSpecializationInfoLookupTable(

GenerateSpecializationInfoLookupTable(

, Specializations, LookupTable,

Offset = Stream.GetCurrentBitNo();

RecordData::value_type

[] = {

RecordData::value_type

(

Stream.EmitRecordWithBlob(IsPartial ? DeclPartialSpecializationsAbbrev

: DeclSpecializationsAbbrev,

.hasExternalDecls() &&

DC->hasNeedToReconcileExternalVisibleStorage();

(

*

:

.getLookupResult()) {

(LocalD->isFromASTFile())

ASTWriter::GenerateNameLookupTable(

assert(!ConstDC->hasLazyLocalLexicalLookups() &&

!ConstDC->hasLazyExternalLexicalLookups() &&

);

ASTDeclContextNameLookupTrait<

>>

ASTDeclContextNameLookupTrait<

> Trait(*

);

&Name = Lookup.first;

&

= Lookup.second;

((GeneratingReducedBMI || isLookupResultExternal(

, DC)) &&

(Lookup.second.getLookupResult().empty())

(Lookup.first.getNameKind()) {

Names.push_back(Lookup.first);

assert(isa<CXXRecordDecl>(DC) &&

);

ConstructorNameSet.insert(Name);

assert(isa<CXXRecordDecl>(DC) &&

);

ConversionNameSet.insert(Name);

(

*

= dyn_cast<CXXRecordDecl>(DC)) {

(ConstructorNameSet.erase(ImplicitCtorName))

Names.push_back(ImplicitCtorName);

(!ConstructorNameSet.empty() || !ConversionNameSet.empty())

(

*ChildD : cast<CXXRecordDecl>(DC)->decls())

(

*ChildND = dyn_cast<NamedDecl>(ChildD)) {

Name = ChildND->getDeclName();

(Name.getNameKind()) {

(ConstructorNameSet.erase(Name))

Names.push_back(Name);

(ConversionNameSet.erase(Name))

Names.push_back(Name);

(ConstructorNameSet.empty() && ConversionNameSet.empty())

assert(ConstructorNameSet.empty() &&

);

assert(ConversionNameSet.empty() &&

);

(

&Name : Names)

(

&Name : Names) {

(Name.getNameKind()) {

ConstructorDecls.append(

.begin(),

.end());

ConversionDecls.append(

.begin(),

.end());

(!ConstructorDecls.empty())

.insert(ConstructorDecls.front()->getDeclName(),

Trait.getData(ConstructorDecls), Trait);

(!ConversionDecls.empty())

.insert(ConversionDecls.front()->getDeclName(),

Trait.getData(ConversionDecls), Trait);

.emit(LookupTable, Trait, Lookups ? &Lookups->Table :

);

&ModuleLocalDecls = Trait.getModuleLocalDecls();

(!ModuleLocalDecls.empty()) {

ModuleLevelNameLookupTrait>

ModuleLocalLookupGenerator;

ModuleLevelNameLookupTrait ModuleLocalTrait(*

);

(

&ModuleLocalIter : ModuleLocalDecls) {

&Key = ModuleLocalIter.first;

&IDs = ModuleLocalIter.second;

ModuleLocalLookupGenerator.insert(Key, ModuleLocalTrait.getData(IDs),

*ModuleLocalLookups =

ModuleLocalLookupGenerator.emit(

ModuleLocalLookupTable, ModuleLocalTrait,

ModuleLocalLookups ? &ModuleLocalLookups->Table :

);

&TULocalDecls = Trait.getTULocalDecls();

ASTDeclContextNameLookupTrait<

>>

ASTDeclContextNameLookupTrait<

> TULocalTrait(

(

&TULocalIter : TULocalDecls) {

&Key = TULocalIter.first;

&IDs = TULocalIter.second;

TULookupGenerator.insert(Key, TULocalTrait.getData(IDs), TULocalTrait);

TULookupGenerator.emit(TULookupTable, TULocalTrait,

TULocalLookups ? &TULocalLookups->Table :

);

ASTWriter::WriteDeclContextVisibleBlock(

&Context,

uint64_t &VisibleBlockOffset,

uint64_t &ModuleLocalBlockOffset,

uint64_t &TULocalBlockOffset) {

assert(VisibleBlockOffset == 0);

assert(ModuleLocalBlockOffset == 0);

assert(TULocalBlockOffset == 0);

(isa<NamespaceDecl>(DC) && Chain &&

(

*Prev = cast<NamespaceDecl>(DC)->getPreviousDecl(); Prev;

Prev = Prev->getPreviousDecl())

(!Prev->isFromASTFile())

LookupResults.reserve(Map->size());

(

&Entry : *Map)

LookupResults.push_back(

std::make_pair(Entry.first, Entry.second.getLookupResult()));

llvm::sort(LookupResults, llvm::less_first());

(

&NameAndResult : LookupResults) {

assert(

.empty() &&

);

(!Map || Map->empty())

VisibleBlockOffset = Stream.GetCurrentBitNo();

GenerateNameLookupTable(Context, DC, LookupTable, ModuleLocalLookupTable,

Stream.EmitRecordWithBlob(DeclContextVisibleLookupAbbrev,

,

++NumVisibleDeclContexts;

(!ModuleLocalLookupTable.empty()) {

ModuleLocalBlockOffset = Stream.GetCurrentBitNo();

assert(ModuleLocalBlockOffset > VisibleBlockOffset);

RecordData::value_type ModuleLocalRecord[] = {

Stream.EmitRecordWithBlob(DeclModuleLocalVisibleLookupAbbrev,

ModuleLocalRecord, ModuleLocalLookupTable);

++NumModuleLocalDeclContexts;

(!TULookupTable.empty()) {

TULocalBlockOffset = Stream.GetCurrentBitNo();

RecordData::value_type TULocalDeclsRecord[] = {

Stream.EmitRecordWithBlob(DeclTULocalLookupAbbrev, TULocalDeclsRecord,

++NumTULocalDeclContexts;

ASTWriter::WriteDeclContextVisibleUpdate(

&Context,

(!Map || Map->empty())

GenerateNameLookupTable(Context, DC, LookupTable, ModuleLocalLookupTable,

(isa<NamespaceDecl>(DC))

Stream.EmitRecordWithBlob(UpdateVisibleAbbrev,

, LookupTable);

(!ModuleLocalLookupTable.empty()) {

RecordData::value_type ModuleLocalRecord[] = {

Stream.EmitRecordWithBlob(ModuleLocalUpdateVisibleAbbrev, ModuleLocalRecord,

ModuleLocalLookupTable);

(!TULookupTable.empty()) {

RecordData::value_type GMFRecord[] = {

Stream.EmitRecordWithBlob(TULocalUpdateVisibleAbbrev, GMFRecord,

ASTWriter::WriteOpenCLExtensions(

&SemaRef) {

(

&I:Opts.OptMap) {

= I.getValue();

.push_back(

.Supported ? 1 : 0);

.push_back(

.Enabled ? 1 : 0);

.push_back(

.WithPragma ? 1 : 0);

ASTWriter::WriteCUDAPragmas(

&SemaRef) {

(SemaRef.

().ForceHostDeviceDepth > 0) {

RecordData::value_type

[] = {SemaRef.

().ForceHostDeviceDepth};

ASTWriter::WriteObjCCategories() {

(

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

StartIndex = Categories.size();

Categories.push_back(0);

Cat =

->known_categories_begin(),

CatEnd =

->known_categories_end();

Cat != CatEnd; ++Cat, ++Size) {

Categories[StartIndex] =

;

CategoriesMap.push_back(CatInfo);

llvm::array_pod_sort(CategoriesMap.begin(), CategoriesMap.end());

;

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

Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));

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

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

Stream.EmitRecordWithBlob(AbbrevID,

,

*

(CategoriesMap.data()),

ASTWriter::WriteLateParsedTemplates(

&SemaRef) {

(

&LPTMapEntry : LPTMap) {

(

&Tok : LPT.

) {

ASTWriter::WriteOptimizePragmaOptions(

&SemaRef) {

ASTWriter::WriteMSStructPragmaOptions(

&SemaRef) {

ASTWriter::WriteMSPointersToMembersPragmaOptions(

&SemaRef) {

ASTWriter::WritePackPragmaOptions(

&SemaRef) {

ASTWriter::WriteFloatControlPragmaOptions(

&SemaRef) {

(

&StackEntry : SemaRef.

.Stack) {

.push_back(StackEntry.Value.getAsOpaqueInt());

ASTWriter::WriteDeclsWithEffectsToVerify(

&SemaRef) {

ASTWriter::WriteModuleFileExtension(

&SemaRef,

Abv = std::make_shared<llvm::BitCodeAbbrev>();

Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));

Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));

Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));

Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));

Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob));

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

.push_back(Metadata.MajorVersion);

.push_back(Metadata.MinorVersion);

.push_back(Metadata.BlockName.size());

.push_back(Metadata.UserInfo.size());

Buffer += Metadata.BlockName;

Buffer += Metadata.UserInfo;

Stream.EmitRecordWithBlob(Abbrev,

, Buffer);

(!A || (isa<PreferredNameAttr>(A) &&

Writer->isWritingStdCXXNamedModules()))

.push_back(0);

.push_back(A->getAttributeSpellingListIndexRaw());

(

*A : Attrs)

tok::annot_pragma_loop_hint: {

.push_back(Info->Toks.size());

(

&

: Info->Toks)

tok::annot_pragma_pack: {

.push_back(

(Info->Action));

tok::annot_pragma_openmp:

tok::annot_pragma_openmp_end:

tok::annot_pragma_unused:

tok::annot_pragma_openacc:

tok::annot_pragma_openacc_end:

tok::annot_repl_input_end:

llvm_unreachable(

);

.push_back(Str.size());

.insert(

.end(), Str.begin(), Str.end());

.push_back(Str.size());

Blob.insert(Blob.end(), Str.begin(), Str.end());

assert(WritingAST &&

);

StringRef PathStr(

.data(),

.size());

(PathStr ==

|| PathStr ==

)

*PathBegin =

.data();

*PathPtr =

(PathPtr != PathBegin) {

.erase(

.begin(),

.begin() + (PathPtr - PathBegin));

Stream.EmitRecordWithBlob(Abbrev,

, FilePath);

.push_back(Version.getMajor());

(std::optional<unsigned> Minor = Version.getMinor())

.push_back(*Minor + 1);

(std::optional<unsigned> Subminor = Version.getSubminor())

.push_back(*Subminor + 1);

assert(ID < IdentifierOffsets.size());

IdentifierOffsets[ID] = Offset;

ID = SelectorIDs[Sel];

assert(ID &&

);

(ID < FirstSelectorID)

SelectorOffsets[ID - FirstSelectorID] = Offset;

<std::shared_ptr<ModuleFileExtension>> Extensions,

IncludeTimestamps,

BuildingImplicitModule,

GeneratingReducedBMI)

: Stream(Stream), Buffer(Buffer), ModuleCache(ModuleCache),

IncludeTimestamps(IncludeTimestamps),

BuildingImplicitModule(BuildingImplicitModule),

GeneratingReducedBMI(GeneratingReducedBMI) {

(

&Ext : Extensions) {

(

Writer = Ext->createExtensionWriter(*

))

ModuleFileExtensionWriters.push_back(std::move(Writer));

assert(WritingAST &&

);

IncludeTimestamps ?

->getModificationTime() : 0;

StringRef OutputFile,

*WritingModule,

StringRef isysroot,

ShouldCacheASTInMemory) {

llvm::TimeTraceScope scope(

, OutputFile);

*SemaPtr = dyn_cast<Sema *>(Subject);

SemaPtr ? SemaPtr->

() : *cast<Preprocessor *>(Subject);

Stream.Emit((

)

, 8);

Stream.Emit((

)

, 8);

Stream.Emit((

)

, 8);

Stream.Emit((

)

, 8);

WriteBlockInfoBlock();

this->WritingModule = WritingModule;

Signature = WriteASTCore(SemaPtr, isysroot, WritingModule);

this->WritingModule =

;

this->BaseDirectory.clear();

WritingAST =

;

(ShouldCacheASTInMemory) {

llvm::MemoryBuffer::getMemBufferCopy(

StringRef(Buffer.begin(), Buffer.size())));

<

Vector>

(

Vector::iterator I = Vec.begin(

,

),

= Vec.end();

<

Vector>

(

Vector::iterator I = Vec.begin(

,

),

= Vec.end();

ASTWriter::computeNonAffectingInputFiles() {

IsSLocAffecting.resize(N,

);

IsSLocFileEntryAffecting.resize(N,

);

AffectingModuleMaps = GetAffectingModuleMaps(*PP, WritingModule);

FileIDAdjustment = 0;

OffsetAdjustment = 0;

NonAffectingFileIDAdjustments.reserve(N);

NonAffectingOffsetAdjustments.reserve(N);

NonAffectingFileIDAdjustments.push_back(FileIDAdjustment);

NonAffectingOffsetAdjustments.push_back(OffsetAdjustment);

(

I = 1; I != N; ++I) {

FID = FileID::get(I);

(!

->OrigEntry)

(!AffectingModuleMaps)

(AffectingModuleMaps->DefinitionFileIDs.contains(FID))

IsSLocAffecting[I] =

;

IsSLocFileEntryAffecting[I] =

AffectingModuleMaps->DefinitionFiles.contains(*

->OrigEntry);

FileIDAdjustment += 1;

(!NonAffectingFileIDs.empty() &&

NonAffectingFileIDs.back().ID == FID.ID - 1) {

NonAffectingFileIDs.back() = FID;

NonAffectingFileIDAdjustments.back() = FileIDAdjustment;

NonAffectingOffsetAdjustments.back() = OffsetAdjustment;

NonAffectingFileIDs.push_back(FID);

NonAffectingFileIDAdjustments.push_back(FileIDAdjustment);

NonAffectingOffsetAdjustments.push_back(OffsetAdjustment);

(StringRef

:

(

I = 1; I != N; ++I) {

(IsSLocAffecting[I]) {

(!

->OrigEntry)

->OrigEntry->getNameAsRequested());

ASTWriter::PrepareWritingSpecialDecls(

&SemaRef) {

isModule = WritingModule !=

;

PredefinedDecls.insert(

);

RegisterPredefDecl(Context.ObjCProtocolClassDecl,

RegisterPredefDecl(Context.ObjCInstanceTypeDecl,

RegisterPredefDecl(Context.BuiltinMSVaListDecl,

RegisterPredefDecl(Context.MakeIntegerSeqDecl,

RegisterPredefDecl(Context.CFConstantStringTypeDecl,

RegisterPredefDecl(Context.CFConstantStringTagDecl,

RegisterPredefDecl(Context.TypePackElementDecl,

(GeneratingReducedBMI) {

(GeneratingReducedBMI)

(

I = 0, N = SemaRef.

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

);

(

&I : SemaRef.KnownNamespaces)

(

&I : Undefined)

(

&DeleteExprsInfo :

(

*I : DeclsToEmitEvenIfUnreferenced)

DeclsToEmitEvenIfUnreferenced.clear();

llvm::sort(IIs, llvm::deref<std::less<>>());

(

*

: SemaRef.DeclsToCheckForDeferredDiags)

PendingEmittingVTables.clear();

ASTWriter::WriteSpecialDeclRecords(

&SemaRef) {

isModule = WritingModule !=

;

(!EagerlyDeserializedDecls.empty())

(!ModularCodegenDecls.empty())

TentativeDefinitions);

(!TentativeDefinitions.empty())

UnusedFileScopedDecls);

(!UnusedFileScopedDecls.empty())

(!ExtVectorDecls.empty())

(

I = 0, N = SemaRef.

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

(!UnusedLocalTypedefNameCandidates.empty())

UnusedLocalTypedefNameCandidates);

(!PendingInstantiations.empty())

AddEmittedDeclRefOrZero = [

, &SemaDeclRefs](

*

) {

SemaDeclRefs.push_back(0);

(!SemaDeclRefs.empty())

(

*

: SemaRef.DeclsToCheckForDeferredDiags)

(!DeclsToCheckForDeferredDiags.empty())

DeclsToCheckForDeferredDiags);

(CudaCallDecl, CUDASpecialDeclRefs);

DelegatingCtorDecls);

(!DelegatingCtorDecls.empty())

(

&I : SemaRef.KnownNamespaces) {

(!KnownNamespaces.empty())

(

&I : Undefined) {

(!UndefinedButUsed.empty())

(

&DeleteExprsInfo :

(DeleteExprsInfo.first, DeleteExprsToAnalyze);

DeleteExprsToAnalyze.push_back(DeleteExprsInfo.second.size());

(

&DeleteLoc : DeleteExprsInfo.second) {

DeleteExprsToAnalyze.push_back(DeleteLoc.second);

(!DeleteExprsToAnalyze.empty())

(!VTablesToEmit.empty())

;

isModule = WritingModule !=

;

computeNonAffectingInputFiles();

writeUnhashedControlBlock(*PP);

IdentifierIDs.clear();

(IsInterestingNonMacroIdentifier(

.second, *

))

IIs.push_back(

.second);

llvm::sort(IIs, llvm::deref<std::less<>>());

(

&WeakUndeclaredIdentifierList :

*

II = WeakUndeclaredIdentifierList.first;

(

&WI : WeakUndeclaredIdentifierList.second) {

(Context, Context.ObjCIdRedefinitionType, SpecialTypes);

(Context, Context.ObjCClassRedefinitionType, SpecialTypes);

(Context, Context.ObjCSelRedefinitionType, SpecialTypes);

PrepareWritingSpecialDecls(*SemaPtr);

WriteControlBlock(*PP, isysroot);

Stream.FlushToWord();

ASTBlockRange.first = Stream.GetCurrentBitNo() >> 3;

ASTBlockStartOffset = Stream.GetCurrentBitNo();

(

&SelectorAndID : SelectorIDs)

AllSelectors.push_back(SelectorAndID.first);

(

&

: AllSelectors)

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

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

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

llvm::raw_svector_ostream Out(Buffer);

llvm::support;

endian::Writer

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

.write<uint8_t>(

uint8_t

(M.

));

.write<uint16_t>(Name.size());

Out.write(Name.data(), Name.size());

writeBaseIDOrNone = [&](

BaseID,

ShouldWrite) {

assert(BaseID < std::numeric_limits<uint32_t>::max() &&

);

Stream.EmitRecordWithBlob(ModuleOffsetMapAbbrev,

,

Buffer.data(), Buffer.size());

WriteDeclAndTypes(SemaPtr->

);

WriteFileDeclIDsMap();

WriteComments(SemaPtr->

);

WritePreprocessor(*PP, isModule);

WriteSelectors(*SemaPtr);

WriteReferencedSelectorsPool(*SemaPtr);

WriteLateParsedTemplates(*SemaPtr);

WriteIdentifierTable(*PP, SemaPtr ? &SemaPtr->

:

, isModule);

WriteOpenCLExtensions(*SemaPtr);

WriteCUDAPragmas(*SemaPtr);

WriteSubmodules(WritingModule, SemaPtr ? &SemaPtr->

:

);

WriteSpecialDeclRecords(*SemaPtr);

(!WeakUndeclaredIdentifiers.empty())

WeakUndeclaredIdentifiers);

(!WritingModule) {

ModuleInfo(uint64_t

,

*M) :

(

), M(M) {}

assert(SubmoduleIDs.contains(I->getImportedModule()));

Imports.push_back(ModuleInfo(SubmoduleIDs[I->getImportedModule()],

I->getImportedModule()));

(!Imports.empty()) {

Cmp = [](

ModuleInfo &A,

ModuleInfo &B) {

= [](

ModuleInfo &A,

ModuleInfo &B) {

A.ID == B.ID;

llvm::sort(Imports, Cmp);

Imports.erase(std::unique(Imports.begin(), Imports.end(),

),

(

&Import : Imports) {

ImportedModules.push_back(

.ID);

WriteObjCCategories();

(!WritingModule) {

WriteOptimizePragmaOptions(*SemaPtr);

WriteMSStructPragmaOptions(*SemaPtr);

WriteMSPointersToMembersPragmaOptions(*SemaPtr);

WritePackPragmaOptions(*SemaPtr);

WriteFloatControlPragmaOptions(*SemaPtr);

WriteDeclsWithEffectsToVerify(*SemaPtr);

RecordData::value_type

[] = {NumStatements,

NumLexicalDeclContexts,

NumVisibleDeclContexts,

NumModuleLocalDeclContexts,

NumTULocalDeclContexts};

Stream.FlushToWord();

ASTBlockRange.second = Stream.GetCurrentBitNo() >> 3;

(

&ExtWriter : ModuleFileExtensionWriters)

WriteModuleFileExtension(*SemaPtr, *ExtWriter);

backpatchSignature();

ASTWriter::EnteringModulePurview() {

(GeneratingReducedBMI)

DeclUpdatesFromGMF.swap(DeclUpdates);

ASTWriter::AddedManglingNumber(

*

,

Number) {

ASTWriter::AddedStaticLocalNumbers(

*

,

Number) {

ASTWriter::WriteDeclAndTypes(

&Context) {

DeclTypesBlockStartOffset = Stream.GetCurrentBitNo();

WriteDeclUpdatesBlocks(Context, DeclUpdatesOffsetsRecord);

(!DeclTypesToEmit.empty()) {

DeclOrType DOT = DeclTypesToEmit.front();

DeclTypesToEmit.pop();

WriteType(Context, DOT.getType());

WriteDecl(Context, DOT.getDecl());

}

(!DeclUpdates.empty());

DoneWritingDeclsAndTypes =

;

assert(DelayedNamespace.empty() || GeneratingReducedBMI);

LexicalOffset = WriteDeclContextLexicalBlock(Context, NS);

WriteDeclContextVisibleBlock(Context, NS, VisibleOffset, ModuleLocalOffset,

LexicalOffset -= DeclTypesBlockStartOffset;

VisibleOffset -= DeclTypesBlockStartOffset;

(ModuleLocalOffset)

ModuleLocalOffset -= DeclTypesBlockStartOffset;

TULocalOffset -= DeclTypesBlockStartOffset;

DelayedNamespaceRecord.push_back(LexicalOffset);

DelayedNamespaceRecord.push_back(VisibleOffset);

DelayedNamespaceRecord.push_back(ModuleLocalOffset);

DelayedNamespaceRecord.push_back(TULocalOffset);

assert(DeclTypesToEmit.empty());

assert(DeclUpdates.empty());

WriteTypeDeclOffsets();

(!DeclUpdatesOffsetsRecord.empty())

(!DelayedNamespaceRecord.empty())

DelayedNamespaceRecord);

(!RelatedDeclsMap.empty()) {

(

&Pair : RelatedDeclsMap) {

RelatedDeclsMapRecord.push_back(Pair.first.getRawValue());

RelatedDeclsMapRecord.push_back(Pair.second.size());

(

&Lambda : Pair.second)

RelatedDeclsMapRecord.push_back(Lambda.getRawValue());

Abv = std::make_shared<llvm::BitCodeAbbrev>();

Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Array));

Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));

FunctionToLambdaMapAbbrev = Stream.EmitAbbrev(std::move(Abv));

FunctionToLambdaMapAbbrev);

(!SpecializationsUpdates.empty()) {

WriteSpecializationsUpdates(

);

SpecializationsUpdates.clear();

(!PartialSpecializationsUpdates.empty()) {

WriteSpecializationsUpdates(

);

PartialSpecializationsUpdates.clear();

NewGlobalKindDeclPairs.push_back(

->

());

NewGlobalKindDeclPairs.push_back(

(

).getRawValue());

Abv = std::make_shared<llvm::BitCodeAbbrev>();

Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob));

TuUpdateLexicalAbbrev = Stream.EmitAbbrev(std::move(Abv));

Stream.EmitRecordWithBlob(TuUpdateLexicalAbbrev,

,

(NewGlobalKindDeclPairs));

Abv = std::make_shared<llvm::BitCodeAbbrev>();

Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));

Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob));

UpdateVisibleAbbrev = Stream.EmitAbbrev(std::move(Abv));

Abv = std::make_shared<llvm::BitCodeAbbrev>();

Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));

Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob));

ModuleLocalUpdateVisibleAbbrev = Stream.EmitAbbrev(std::move(Abv));

Abv = std::make_shared<llvm::BitCodeAbbrev>();

Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));

Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob));

TULocalUpdateVisibleAbbrev = Stream.EmitAbbrev(std::move(Abv));

WriteDeclContextVisibleUpdate(Context, TU);

(Context.ExternCContext)

WriteDeclContextVisibleUpdate(Context, Context.ExternCContext);

(

*DC : UpdatedDeclContexts)

WriteDeclContextVisibleUpdate(Context, DC);

ASTWriter::WriteSpecializationsUpdates(

IsPartial) {

Abv = std::make_shared<llvm::BitCodeAbbrev>();

Abv->Add(llvm::BitCodeAbbrevOp(

));

Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));

Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob));

UpdateSpecializationAbbrev = Stream.EmitAbbrev(std::move(Abv));

IsPartial ? PartialSpecializationsUpdates : SpecializationsUpdates;

(

&SpecializationUpdate : SpecUpdates) {

*

= SpecializationUpdate.first;

GenerateSpecializationInfoLookupTable(

, SpecializationUpdate.second,

LookupTable, IsPartial);

RecordData::value_type

[] = {

RecordData::value_type

(

),

Stream.EmitRecordWithBlob(UpdateSpecializationAbbrev,

, LookupTable);

ASTWriter::WriteDeclUpdatesBlocks(

&Context,

RecordDataImpl &OffsetsRecord) {

(DeclUpdates.empty())

DeclUpdateMap LocalUpdates;

LocalUpdates.swap(DeclUpdates);

(

&DeclUpdate : LocalUpdates) {

*

= DeclUpdate.first;

HasUpdatedBody =

;

HasAddedVarDefinition =

;

(

&

: DeclUpdate.second) {

HasUpdatedBody =

;

HasAddedVarDefinition =

;

assert(

.getDecl() &&

);

cast<ParmVarDecl>(

.getDecl())->getDefaultArg());

cast<FieldDecl>(

.getDecl())->getInClassInitializer());

*RD = cast<CXXRecordDecl>(

);

UpdatedDeclContexts.insert(RD->getPrimaryContext());

.push_back(RD->isParamDestroyedInCallee());

.push_back(llvm::to_underlying(RD->getArgPassingRestrictions()));

.AddCXXDefinitionData(RD);

.AddOffset(WriteDeclContextLexicalBlock(Context, RD));

(

*MSInfo = RD->getMemberSpecializationInfo()) {

.push_back(MSInfo->getTemplateSpecializationKind());

.AddSourceLocation(MSInfo->getPointOfInstantiation());

*Spec = cast<ClassTemplateSpecializationDecl>(RD);

.push_back(Spec->getTemplateSpecializationKind());

.AddSourceLocation(Spec->getPointOfInstantiation());

From = Spec->getInstantiatedFrom();

(

PartialSpec =

.push_back(

);

.AddDeclRef(PartialSpec);

.AddTemplateArgumentList(

&Spec->getTemplateInstantiationArgs());

.push_back(

);

.push_back(llvm::to_underlying(RD->getTagKind()));

.AddSourceLocation(RD->getLocation());

.AddSourceLocation(RD->getBeginLoc());

.AddSourceRange(RD->getBraceRange());

.AddStmt(cast<CXXDestructorDecl>(

)->getOperatorDeleteThisArg());

.writeExceptionSpecInfo(prototype->getExceptionSpecInfo());

->

<OMPThreadPrivateDeclAttr>()->getRange());

*A =

->

<OMPAllocateDeclAttr>();

.push_back(A->getAllocatorType());

.AddStmt(A->getAllocator());

.AddStmt(A->getAlignment());

.AddSourceRange(A->getRange());

.push_back(

->

<OMPDeclareTargetDeclAttr>()->getMapType());

->

<OMPDeclareTargetDeclAttr>()->getRange());

.push_back(getSubmoduleID(

.getModule()));

(HasUpdatedBody) {

*Def = cast<FunctionDecl>(

);

.push_back(Def->isInlined());

.AddSourceLocation(Def->getInnerLocStart());

.AddFunctionDefinition(Def);

}

(HasAddedVarDefinition) {

*VD = cast<VarDecl>(

);

.push_back(VD->isInline());

.push_back(VD->isInlineSpecified());

.AddVarDeclInit(VD);

ASTWriter::getAdjustedFileID(

FID)

{

NonAffectingFileIDs.empty())

It = llvm::lower_bound(NonAffectingFileIDs, FID);

Idx = std::distance(NonAffectingFileIDs.begin(), It);

Offset = NonAffectingFileIDAdjustments[Idx];

FileID::get(FID.getOpaqueValue() - Offset);

ASTWriter::getAdjustedNumCreatedFIDs(

FID)

{

AdjustedNumCreatedFIDs = 0;