On Thu, Sep 10, 2015 at 9:13 AM, David Blaikie via cfe-commits < cfe-commits@lists.llvm.org> wrote:
> > > On Thu, Sep 10, 2015 at 9:07 AM, Mehdi Amini <mehdi.am...@apple.com> > wrote: > >> >> On Sep 10, 2015, at 9:02 AM, David Blaikie <dblai...@gmail.com> wrote: >> >> >> >> On Thu, Sep 10, 2015 at 9:00 AM, Mehdi Amini <mehdi.am...@apple.com> >> wrote: >> >>> >>> On Sep 9, 2015, at 7:06 PM, David Blaikie <dblai...@gmail.com> wrote: >>> >>> >>> >>> On Wed, Sep 9, 2015 at 6:46 PM, Mehdi Amini via cfe-commits < >>> cfe-commits@lists.llvm.org> wrote: >>> >>>> Author: mehdi_amini >>>> Date: Wed Sep 9 20:46:39 2015 >>>> New Revision: 247233 >>>> >>>> URL: http://llvm.org/viewvc/llvm-project?rev=247233&view=rev >>>> Log: >>>> EmitRecord* API change: accepts ArrayRef instead of a SmallVector (NFC) >>>> >>>> This reapply a variant commit r247179 after post-commit review from >>>> D.Blaikie. >>>> Hopefully I got it right this time: lifetime of initializer list ends >>>> as with any expression, which make invalid the pattern: >>>> >>>> ArrayRef<int> Arr = { 1, 2, 3, 4}; >>>> >>>> Just like StringRef, ArrayRef shouldn't be used to initialize local >>>> variable but only as function argument. >>>> >>> >>> Looks pretty reasonable - I'll mention it again, just in case: removing >>> the named variables and just putting the init lists directly in the call >>> might be as (or more) readable - might be worth giving it a go & running it >>> through clang-format to see what you think. >>> >>> >>> Here is an example, let me know what do you think: >>> >>> { >>> RecordData::value_type Record[] = {METADATA, VERSION_MAJOR, >>> VERSION_MINOR, >>> CLANG_VERSION_MAJOR, >>> CLANG_VERSION_MINOR, >>> !isysroot.empty(), >>> IncludeTimestamps, >>> ASTHasCompilerErrors}; >>> Stream.EmitRecordWithBlob(MetadataAbbrevCode, Record, >>> getClangFullRepositoryVersion()); >>> } >>> Stream.EmitRecordWithBlob( >>> MetadataAbbrevCode, >>> (uint64_t[]){METADATA, VERSION_MAJOR, VERSION_MINOR, >>> CLANG_VERSION_MAJOR, >>> >> >> Why the cast (uint64_t[])? I'm vaguely surprised that even compiles... ? >> >> This is a GNU extension (C99 compound literals in C++). It won't compile on MSVC. > I would imagine it'd be passed as an init list, then turned into an >> ArrayRef from there... but I guess not? >> >> >> >> Might be more clear with the callee: >> >> template <typename Container> >> void EmitRecordWithBlob(unsigned Abbrev, const Container &Vals, >> StringRef Blob) { >> EmitRecordWithAbbrevImpl(Abbrev, makeArrayRef(Vals), Blob, None); >> } >> >> The template can’t be deduced without the cast. >> > > Yeah, curious though. Another hole in perfect forwarding I suppose (not > that this ^ is perfect forwarding, but even with perfect forwarding it > doesn't cope well) > > Yeah, the cast is rather unfortunate. Hrm. > > Ah well - probably just as good to leave it as-is for now. If someone has > a flash of inspiration later & figures out a way to make it better, so be > it. > The way to handle this is to add another EmitRecord overload that takes a std::initializer_list<uint64_t>. >> — >> Mehdi >> >> >> >> >> >> >> >> >>> CLANG_VERSION_MINOR, !isysroot.empty(), >>> IncludeTimestamps, >>> ASTHasCompilerErrors}, >>> getClangFullRepositoryVersion()); >>> >>> Thanks, >>> >>> — >>> Mehdi >>> >>> >>> >>> >>> >>> >>> >>> - Dave >>> >>> >>>> >>>> From: Mehdi Amini <mehdi.am...@apple.com> >>>> >>>> Modified: >>>> cfe/trunk/include/clang/Serialization/ASTWriter.h >>>> cfe/trunk/lib/Frontend/SerializedDiagnosticPrinter.cpp >>>> cfe/trunk/lib/Serialization/ASTWriter.cpp >>>> cfe/trunk/lib/Serialization/GlobalModuleIndex.cpp >>>> >>>> Modified: cfe/trunk/include/clang/Serialization/ASTWriter.h >>>> URL: >>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Serialization/ASTWriter.h?rev=247233&r1=247232&r2=247233&view=diff >>>> >>>> ============================================================================== >>>> --- cfe/trunk/include/clang/Serialization/ASTWriter.h (original) >>>> +++ cfe/trunk/include/clang/Serialization/ASTWriter.h Wed Sep 9 >>>> 20:46:39 2015 >>>> @@ -84,6 +84,7 @@ class ASTWriter : public ASTDeserializat >>>> public: >>>> typedef SmallVector<uint64_t, 64> RecordData; >>>> typedef SmallVectorImpl<uint64_t> RecordDataImpl; >>>> + typedef ArrayRef<uint64_t> RecordDataRef; >>>> >>>> friend class ASTDeclWriter; >>>> friend class ASTStmtWriter; >>>> @@ -756,7 +757,7 @@ public: >>>> void AddPath(StringRef Path, RecordDataImpl &Record); >>>> >>>> /// \brief Emit the current record with the given path as a blob. >>>> - void EmitRecordWithPath(unsigned Abbrev, RecordDataImpl &Record, >>>> + void EmitRecordWithPath(unsigned Abbrev, RecordDataRef Record, >>>> StringRef Path); >>>> >>>> /// \brief Add a version tuple to the given record >>>> >>>> Modified: cfe/trunk/lib/Frontend/SerializedDiagnosticPrinter.cpp >>>> URL: >>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Frontend/SerializedDiagnosticPrinter.cpp?rev=247233&r1=247232&r2=247233&view=diff >>>> >>>> ============================================================================== >>>> --- cfe/trunk/lib/Frontend/SerializedDiagnosticPrinter.cpp (original) >>>> +++ cfe/trunk/lib/Frontend/SerializedDiagnosticPrinter.cpp Wed Sep 9 >>>> 20:46:39 2015 >>>> @@ -51,6 +51,7 @@ public: >>>> >>>> typedef SmallVector<uint64_t, 64> RecordData; >>>> typedef SmallVectorImpl<uint64_t> RecordDataImpl; >>>> +typedef ArrayRef<uint64_t> RecordDataRef; >>>> >>>> class SDiagsWriter; >>>> >>>> @@ -393,13 +394,9 @@ unsigned SDiagsWriter::getEmitFile(const >>>> >>>> // Lazily generate the record for the file. >>>> entry = State->Files.size(); >>>> - RecordData Record; >>>> - Record.push_back(RECORD_FILENAME); >>>> - Record.push_back(entry); >>>> - Record.push_back(0); // For legacy. >>>> - Record.push_back(0); // For legacy. >>>> StringRef Name(FileName); >>>> - Record.push_back(Name.size()); >>>> + RecordData::value_type Record[] = {RECORD_FILENAME, entry, 0 /* For >>>> legacy */, >>>> + 0 /* For legacy */, Name.size()}; >>>> >>>> State->Stream.EmitRecordWithBlob(State->Abbrevs.get(RECORD_FILENAME), >>>> Record, >>>> Name); >>>> >>>> @@ -531,14 +528,11 @@ void SDiagsWriter::EmitBlockInfoBlock() >>>> >>>> void SDiagsWriter::EmitMetaBlock() { >>>> llvm::BitstreamWriter &Stream = State->Stream; >>>> - RecordData &Record = State->Record; >>>> AbbreviationMap &Abbrevs = State->Abbrevs; >>>> >>>> Stream.EnterSubblock(BLOCK_META, 3); >>>> - Record.clear(); >>>> - Record.push_back(RECORD_VERSION); >>>> - Record.push_back(VersionNumber); >>>> - Stream.EmitRecordWithAbbrev(Abbrevs.get(RECORD_VERSION), Record); >>>> + RecordData::value_type Record[] = {RECORD_VERSION, VersionNumber}; >>>> + Stream.EmitRecordWithAbbrev(Abbrevs.get(RECORD_VERSION), Record); >>>> Stream.ExitBlock(); >>>> } >>>> >>>> @@ -548,11 +542,8 @@ unsigned SDiagsWriter::getEmitCategory(u >>>> >>>> // We use a local version of 'Record' so that we can be generating >>>> // another record when we lazily generate one for the category entry. >>>> - RecordData Record; >>>> - Record.push_back(RECORD_CATEGORY); >>>> - Record.push_back(category); >>>> StringRef catName = DiagnosticIDs::getCategoryNameFromID(category); >>>> - Record.push_back(catName.size()); >>>> + RecordData::value_type Record[] = {RECORD_CATEGORY, category, >>>> catName.size()}; >>>> >>>> State->Stream.EmitRecordWithBlob(State->Abbrevs.get(RECORD_CATEGORY), >>>> Record, >>>> catName); >>>> >>>> @@ -581,10 +572,8 @@ unsigned SDiagsWriter::getEmitDiagnostic >>>> entry.second = FlagName; >>>> >>>> // Lazily emit the string in a separate record. >>>> - RecordData Record; >>>> - Record.push_back(RECORD_DIAG_FLAG); >>>> - Record.push_back(entry.first); >>>> - Record.push_back(FlagName.size()); >>>> + RecordData::value_type Record[] = {RECORD_DIAG_FLAG, entry.first, >>>> + FlagName.size()}; >>>> >>>> State->Stream.EmitRecordWithBlob(State->Abbrevs.get(RECORD_DIAG_FLAG), >>>> Record, FlagName); >>>> } >>>> @@ -844,17 +833,9 @@ std::error_code SDiagsMerger::visitEndOf >>>> std::error_code >>>> SDiagsMerger::visitSourceRangeRecord(const serialized_diags::Location >>>> &Start, >>>> const serialized_diags::Location >>>> &End) { >>>> - RecordData Record; >>>> - Record.push_back(RECORD_SOURCE_RANGE); >>>> - Record.push_back(FileLookup[Start.FileID]); >>>> - Record.push_back(Start.Line); >>>> - Record.push_back(Start.Col); >>>> - Record.push_back(Start.Offset); >>>> - Record.push_back(FileLookup[End.FileID]); >>>> - Record.push_back(End.Line); >>>> - Record.push_back(End.Col); >>>> - Record.push_back(End.Offset); >>>> - >>>> + RecordData::value_type Record[] = { >>>> + RECORD_SOURCE_RANGE, FileLookup[Start.FileID], Start.Line, >>>> Start.Col, >>>> + Start.Offset, FileLookup[End.FileID], End.Line, End.Col, >>>> End.Offset}; >>>> Writer.State->Stream.EmitRecordWithAbbrev( >>>> Writer.State->Abbrevs.get(RECORD_SOURCE_RANGE), Record); >>>> return std::error_code(); >>>> @@ -863,19 +844,13 @@ SDiagsMerger::visitSourceRangeRecord(con >>>> std::error_code SDiagsMerger::visitDiagnosticRecord( >>>> unsigned Severity, const serialized_diags::Location &Location, >>>> unsigned Category, unsigned Flag, StringRef Message) { >>>> - RecordData MergedRecord; >>>> - MergedRecord.push_back(RECORD_DIAG); >>>> - MergedRecord.push_back(Severity); >>>> - MergedRecord.push_back(FileLookup[Location.FileID]); >>>> - MergedRecord.push_back(Location.Line); >>>> - MergedRecord.push_back(Location.Col); >>>> - MergedRecord.push_back(Location.Offset); >>>> - MergedRecord.push_back(CategoryLookup[Category]); >>>> - MergedRecord.push_back(Flag ? DiagFlagLookup[Flag] : 0); >>>> - MergedRecord.push_back(Message.size()); >>>> + RecordData::value_type Record[] = { >>>> + RECORD_DIAG, Severity, FileLookup[Location.FileID], >>>> Location.Line, >>>> + Location.Col, Location.Offset, CategoryLookup[Category], >>>> + Flag ? DiagFlagLookup[Flag] : 0, Message.size()}; >>>> >>>> Writer.State->Stream.EmitRecordWithBlob( >>>> - Writer.State->Abbrevs.get(RECORD_DIAG), MergedRecord, Message); >>>> + Writer.State->Abbrevs.get(RECORD_DIAG), Record, Message); >>>> return std::error_code(); >>>> } >>>> >>>> @@ -883,17 +858,10 @@ std::error_code >>>> SDiagsMerger::visitFixitRecord(const serialized_diags::Location &Start, >>>> const serialized_diags::Location &End, >>>> StringRef Text) { >>>> - RecordData Record; >>>> - Record.push_back(RECORD_FIXIT); >>>> - Record.push_back(FileLookup[Start.FileID]); >>>> - Record.push_back(Start.Line); >>>> - Record.push_back(Start.Col); >>>> - Record.push_back(Start.Offset); >>>> - Record.push_back(FileLookup[End.FileID]); >>>> - Record.push_back(End.Line); >>>> - Record.push_back(End.Col); >>>> - Record.push_back(End.Offset); >>>> - Record.push_back(Text.size()); >>>> + RecordData::value_type Record[] = {RECORD_FIXIT, >>>> FileLookup[Start.FileID], >>>> + Start.Line, Start.Col, >>>> Start.Offset, >>>> + FileLookup[End.FileID], End.Line, >>>> End.Col, >>>> + End.Offset, Text.size()}; >>>> >>>> Writer.State->Stream.EmitRecordWithBlob( >>>> Writer.State->Abbrevs.get(RECORD_FIXIT), Record, Text); >>>> >>>> Modified: cfe/trunk/lib/Serialization/ASTWriter.cpp >>>> URL: >>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Serialization/ASTWriter.cpp?rev=247233&r1=247232&r2=247233&view=diff >>>> >>>> ============================================================================== >>>> --- cfe/trunk/lib/Serialization/ASTWriter.cpp (original) >>>> +++ cfe/trunk/lib/Serialization/ASTWriter.cpp Wed Sep 9 20:46:39 2015 >>>> @@ -1185,27 +1185,23 @@ void ASTWriter::WriteControlBlock(Prepro >>>> MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // >>>> Errors >>>> MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // SVN >>>> branch/tag >>>> unsigned MetadataAbbrevCode = Stream.EmitAbbrev(MetadataAbbrev); >>>> - Record.push_back(METADATA); >>>> - Record.push_back(VERSION_MAJOR); >>>> - Record.push_back(VERSION_MINOR); >>>> - Record.push_back(CLANG_VERSION_MAJOR); >>>> - Record.push_back(CLANG_VERSION_MINOR); >>>> assert((!WritingModule || isysroot.empty()) && >>>> "writing module as a relocatable PCH?"); >>>> - Record.push_back(!isysroot.empty()); >>>> - Record.push_back(IncludeTimestamps); >>>> - Record.push_back(ASTHasCompilerErrors); >>>> - Stream.EmitRecordWithBlob(MetadataAbbrevCode, Record, >>>> - getClangFullRepositoryVersion()); >>>> - >>>> + { >>>> + RecordData::value_type Record[] = {METADATA, VERSION_MAJOR, >>>> VERSION_MINOR, >>>> + CLANG_VERSION_MAJOR, >>>> CLANG_VERSION_MINOR, >>>> + !isysroot.empty(), >>>> IncludeTimestamps, >>>> + ASTHasCompilerErrors}; >>>> + Stream.EmitRecordWithBlob(MetadataAbbrevCode, Record, >>>> + getClangFullRepositoryVersion()); >>>> + } >>>> if (WritingModule) { >>>> // For implicit modules we output a signature that we can use to >>>> ensure >>>> // duplicate module builds don't collide in the cache as their >>>> output order >>>> // is non-deterministic. >>>> // FIXME: Remove this when output is deterministic. >>>> if (Context.getLangOpts().ImplicitModules) { >>>> - Record.clear(); >>>> - Record.push_back(getSignature()); >>>> + RecordData::value_type Record[] = {getSignature()}; >>>> Stream.EmitRecord(SIGNATURE, Record); >>>> } >>>> >>>> @@ -1214,8 +1210,7 @@ void ASTWriter::WriteControlBlock(Prepro >>>> Abbrev->Add(BitCodeAbbrevOp(MODULE_NAME)); >>>> Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name >>>> unsigned AbbrevCode = Stream.EmitAbbrev(Abbrev); >>>> - RecordData Record; >>>> - Record.push_back(MODULE_NAME); >>>> + RecordData::value_type Record[] = {MODULE_NAME}; >>>> Stream.EmitRecordWithBlob(AbbrevCode, Record, WritingModule->Name); >>>> } >>>> >>>> @@ -1236,8 +1231,7 @@ void ASTWriter::WriteControlBlock(Prepro >>>> Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Directory >>>> unsigned AbbrevCode = Stream.EmitAbbrev(Abbrev); >>>> >>>> - RecordData Record; >>>> - Record.push_back(MODULE_DIRECTORY); >>>> + RecordData::value_type Record[] = {MODULE_DIRECTORY}; >>>> Stream.EmitRecordWithBlob(AbbrevCode, Record, BaseDir); >>>> } >>>> >>>> @@ -1466,8 +1460,7 @@ void ASTWriter::WriteControlBlock(Prepro >>>> SM.getFileManager().makeAbsolutePath(OutputPath); >>>> StringRef origDir = llvm::sys::path::parent_path(OutputPath); >>>> >>>> - RecordData Record; >>>> - Record.push_back(ORIGINAL_PCH_DIR); >>>> + RecordData::value_type Record[] = {ORIGINAL_PCH_DIR}; >>>> Stream.EmitRecordWithBlob(AbbrevCode, Record, origDir); >>>> } >>>> >>>> @@ -1491,8 +1484,7 @@ void ASTWriter::WriteInputFiles(SourceMa >>>> bool Modules) { >>>> using namespace llvm; >>>> Stream.EnterSubblock(INPUT_FILES_BLOCK_ID, 4); >>>> - RecordData Record; >>>> - >>>> + >>>> // Create input-file abbreviation. >>>> BitCodeAbbrev *IFAbbrev = new BitCodeAbbrev(); >>>> IFAbbrev->Add(BitCodeAbbrevOp(INPUT_FILE)); >>>> @@ -1547,16 +1539,11 @@ void ASTWriter::WriteInputFiles(SourceMa >>>> if (!Entry.IsSystemFile) >>>> ++UserFilesNum; >>>> >>>> - Record.clear(); >>>> - Record.push_back(INPUT_FILE); >>>> - Record.push_back(InputFileOffsets.size()); >>>> - >>>> // Emit size/modification time for this file. >>>> - Record.push_back(Entry.File->getSize()); >>>> - Record.push_back(getTimestampForOutput(Entry.File)); >>>> - >>>> - // Whether this file was overridden. >>>> - Record.push_back(Entry.BufferOverridden); >>>> + // And whether this file was overridden. >>>> + RecordData::value_type Record[] = { >>>> + INPUT_FILE, InputFileOffsets.size(), >>>> (uint64_t)Entry.File->getSize(), >>>> + (uint64_t)getTimestampForOutput(Entry.File), >>>> Entry.BufferOverridden}; >>>> >>>> EmitRecordWithPath(IFAbbrevCode, Record, Entry.File->getName()); >>>> } >>>> @@ -1573,10 +1560,8 @@ void ASTWriter::WriteInputFiles(SourceMa >>>> unsigned OffsetsAbbrevCode = Stream.EmitAbbrev(OffsetsAbbrev); >>>> >>>> // Write input file offsets. >>>> - Record.clear(); >>>> - Record.push_back(INPUT_FILE_OFFSETS); >>>> - Record.push_back(InputFileOffsets.size()); >>>> - Record.push_back(UserFilesNum); >>>> + RecordData::value_type Record[] = {INPUT_FILE_OFFSETS, >>>> + InputFileOffsets.size(), >>>> UserFilesNum}; >>>> Stream.EmitRecordWithBlob(OffsetsAbbrevCode, Record, >>>> bytes(InputFileOffsets)); >>>> } >>>> >>>> @@ -1818,11 +1803,8 @@ void ASTWriter::WriteHeaderSearch(const >>>> unsigned TableAbbrev = Stream.EmitAbbrev(Abbrev); >>>> >>>> // Write the header search table >>>> - RecordData Record; >>>> - Record.push_back(HEADER_SEARCH_TABLE); >>>> - Record.push_back(BucketOffset); >>>> - Record.push_back(NumHeaderSearchEntries); >>>> - Record.push_back(TableData.size()); >>>> + RecordData::value_type Record[] = {HEADER_SEARCH_TABLE, BucketOffset, >>>> + NumHeaderSearchEntries, >>>> TableData.size()}; >>>> >>>> >>>> TableData.append(GeneratorTrait.strings_begin(),GeneratorTrait.strings_end()); >>>> Stream.EmitRecordWithBlob(TableAbbrev, Record, TableData); >>>> >>>> @@ -1911,8 +1893,7 @@ void ASTWriter::WriteSourceManagerBlock( >>>> Stream.EmitRecordWithAbbrev(SLocFileAbbrv, Record); >>>> >>>> if (Content->BufferOverridden) { >>>> - Record.clear(); >>>> - Record.push_back(SM_SLOC_BUFFER_BLOB); >>>> + RecordData::value_type Record[] = {SM_SLOC_BUFFER_BLOB}; >>>> const llvm::MemoryBuffer *Buffer >>>> = Content->getBuffer(PP.getDiagnostics(), >>>> PP.getSourceManager()); >>>> Stream.EmitRecordWithBlob(SLocBufferBlobAbbrv, Record, >>>> @@ -1931,8 +1912,7 @@ void ASTWriter::WriteSourceManagerBlock( >>>> const char *Name = Buffer->getBufferIdentifier(); >>>> Stream.EmitRecordWithBlob(SLocBufferAbbrv, Record, >>>> StringRef(Name, strlen(Name) + 1)); >>>> - Record.clear(); >>>> - Record.push_back(SM_SLOC_BUFFER_BLOB); >>>> + RecordData::value_type Record[] = {SM_SLOC_BUFFER_BLOB}; >>>> Stream.EmitRecordWithBlob(SLocBufferBlobAbbrv, Record, >>>> StringRef(Buffer->getBufferStart(), >>>> >>>> Buffer->getBufferSize() + 1)); >>>> @@ -1972,13 +1952,13 @@ void ASTWriter::WriteSourceManagerBlock( >>>> Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // total size >>>> Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // offsets >>>> unsigned SLocOffsetsAbbrev = Stream.EmitAbbrev(Abbrev); >>>> - >>>> - Record.clear(); >>>> - Record.push_back(SOURCE_LOCATION_OFFSETS); >>>> - Record.push_back(SLocEntryOffsets.size()); >>>> - Record.push_back(SourceMgr.getNextLocalOffset() - 1); // skip dummy >>>> - Stream.EmitRecordWithBlob(SLocOffsetsAbbrev, Record, >>>> bytes(SLocEntryOffsets)); >>>> - >>>> + { >>>> + RecordData::value_type Record[] = { >>>> + SOURCE_LOCATION_OFFSETS, SLocEntryOffsets.size(), >>>> + SourceMgr.getNextLocalOffset() - 1 /* skip dummy */}; >>>> + Stream.EmitRecordWithBlob(SLocOffsetsAbbrev, Record, >>>> + bytes(SLocEntryOffsets)); >>>> + } >>>> // Write the source location entry preloads array, telling the AST >>>> // reader which source locations entries it should load eagerly. >>>> Stream.EmitRecord(SOURCE_LOCATION_PRELOADS, PreloadSLocs); >>>> @@ -2064,9 +2044,8 @@ void ASTWriter::WritePreprocessor(const >>>> >>>> // If the preprocessor __COUNTER__ value has been bumped, remember >>>> it. >>>> if (PP.getCounterValue() != 0) { >>>> - Record.push_back(PP.getCounterValue()); >>>> + RecordData::value_type Record[] = {PP.getCounterValue()}; >>>> Stream.EmitRecord(PP_COUNTER_VALUE, Record); >>>> - Record.clear(); >>>> } >>>> >>>> // Enter the preprocessor block. >>>> @@ -2232,12 +2211,11 @@ void ASTWriter::WritePreprocessor(const >>>> Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); >>>> >>>> unsigned MacroOffsetAbbrev = Stream.EmitAbbrev(Abbrev); >>>> - Record.clear(); >>>> - Record.push_back(MACRO_OFFSET); >>>> - Record.push_back(MacroOffsets.size()); >>>> - Record.push_back(FirstMacroID - NUM_PREDEF_MACRO_IDS); >>>> - Stream.EmitRecordWithBlob(MacroOffsetAbbrev, Record, >>>> - bytes(MacroOffsets)); >>>> + { >>>> + RecordData::value_type Record[] = {MACRO_OFFSET, >>>> MacroOffsets.size(), >>>> + FirstMacroID - >>>> NUM_PREDEF_MACRO_IDS}; >>>> + Stream.EmitRecordWithBlob(MacroOffsetAbbrev, Record, >>>> bytes(MacroOffsets)); >>>> + } >>>> } >>>> >>>> void ASTWriter::WritePreprocessorDetail(PreprocessingRecord &PPRec) { >>>> @@ -2331,9 +2309,9 @@ void ASTWriter::WritePreprocessorDetail( >>>> Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); >>>> unsigned PPEOffsetAbbrev = Stream.EmitAbbrev(Abbrev); >>>> >>>> - Record.clear(); >>>> - Record.push_back(PPD_ENTITIES_OFFSETS); >>>> - Record.push_back(FirstPreprocessorEntityID - >>>> NUM_PREDEF_PP_ENTITY_IDS); >>>> + RecordData::value_type Record[] = {PPD_ENTITIES_OFFSETS, >>>> + FirstPreprocessorEntityID - >>>> + NUM_PREDEF_PP_ENTITY_IDS}; >>>> Stream.EmitRecordWithBlob(PPEOffsetAbbrev, Record, >>>> bytes(PreprocessedEntityOffsets)); >>>> } >>>> @@ -2460,9 +2438,9 @@ void ASTWriter::WriteSubmodules(Module * >>>> unsigned ConflictAbbrev = Stream.EmitAbbrev(Abbrev); >>>> >>>> // Write the submodule metadata block. >>>> - RecordData Record; >>>> - Record.push_back(getNumberOfModules(WritingModule)); >>>> - Record.push_back(FirstSubmoduleID - NUM_PREDEF_SUBMODULE_IDS); >>>> + RecordData::value_type Record[] = {getNumberOfModules(WritingModule), >>>> + FirstSubmoduleID - >>>> + NUM_PREDEF_SUBMODULE_IDS}; >>>> Stream.EmitRecord(SUBMODULE_METADATA, Record); >>>> >>>> // Write all of the submodules. >>>> @@ -2472,45 +2450,37 @@ void ASTWriter::WriteSubmodules(Module * >>>> Module *Mod = Q.front(); >>>> Q.pop(); >>>> unsigned ID = getSubmoduleID(Mod); >>>> - >>>> - // Emit the definition of the block. >>>> - Record.clear(); >>>> - Record.push_back(SUBMODULE_DEFINITION); >>>> - Record.push_back(ID); >>>> + >>>> + uint64_t ParentID = 0; >>>> if (Mod->Parent) { >>>> assert(SubmoduleIDs[Mod->Parent] && "Submodule parent not >>>> written?"); >>>> - Record.push_back(SubmoduleIDs[Mod->Parent]); >>>> - } else { >>>> - Record.push_back(0); >>>> + ParentID = SubmoduleIDs[Mod->Parent]; >>>> } >>>> - Record.push_back(Mod->IsFramework); >>>> - Record.push_back(Mod->IsExplicit); >>>> - Record.push_back(Mod->IsSystem); >>>> - Record.push_back(Mod->IsExternC); >>>> - Record.push_back(Mod->InferSubmodules); >>>> - Record.push_back(Mod->InferExplicitSubmodules); >>>> - Record.push_back(Mod->InferExportWildcard); >>>> - Record.push_back(Mod->ConfigMacrosExhaustive); >>>> - Stream.EmitRecordWithBlob(DefinitionAbbrev, Record, Mod->Name); >>>> - >>>> + >>>> + // Emit the definition of the block. >>>> + { >>>> + RecordData::value_type Record[] = { >>>> + SUBMODULE_DEFINITION, ID, ParentID, Mod->IsFramework, >>>> Mod->IsExplicit, >>>> + Mod->IsSystem, Mod->IsExternC, Mod->InferSubmodules, >>>> + Mod->InferExplicitSubmodules, Mod->InferExportWildcard, >>>> + Mod->ConfigMacrosExhaustive}; >>>> + Stream.EmitRecordWithBlob(DefinitionAbbrev, Record, Mod->Name); >>>> + } >>>> + >>>> // Emit the requirements. >>>> for (const auto &R : Mod->Requirements) { >>>> - Record.clear(); >>>> - Record.push_back(SUBMODULE_REQUIRES); >>>> - Record.push_back(R.second); >>>> + RecordData::value_type Record[] = {SUBMODULE_REQUIRES, R.second}; >>>> Stream.EmitRecordWithBlob(RequiresAbbrev, Record, R.first); >>>> } >>>> >>>> // Emit the umbrella header, if there is one. >>>> if (auto UmbrellaHeader = Mod->getUmbrellaHeader()) { >>>> - Record.clear(); >>>> - Record.push_back(SUBMODULE_UMBRELLA_HEADER); >>>> + RecordData::value_type Record[] = {SUBMODULE_UMBRELLA_HEADER}; >>>> Stream.EmitRecordWithBlob(UmbrellaAbbrev, Record, >>>> UmbrellaHeader.NameAsWritten); >>>> } else if (auto UmbrellaDir = Mod->getUmbrellaDir()) { >>>> - Record.clear(); >>>> - Record.push_back(SUBMODULE_UMBRELLA_DIR); >>>> - Stream.EmitRecordWithBlob(UmbrellaDirAbbrev, Record, >>>> + RecordData::value_type Record[] = {SUBMODULE_UMBRELLA_DIR}; >>>> + Stream.EmitRecordWithBlob(UmbrellaDirAbbrev, Record, >>>> UmbrellaDir.NameAsWritten); >>>> } >>>> >>>> @@ -2528,8 +2498,7 @@ void ASTWriter::WriteSubmodules(Module * >>>> {SUBMODULE_EXCLUDED_HEADER, ExcludedHeaderAbbrev, >>>> Module::HK_Excluded} >>>> }; >>>> for (auto &HL : HeaderLists) { >>>> - Record.clear(); >>>> - Record.push_back(HL.RecordKind); >>>> + RecordData::value_type Record[] = {HL.RecordKind}; >>>> for (auto &H : Mod->Headers[HL.HeaderKind]) >>>> Stream.EmitRecordWithBlob(HL.Abbrev, Record, H.NameAsWritten); >>>> } >>>> @@ -2537,15 +2506,14 @@ void ASTWriter::WriteSubmodules(Module * >>>> // Emit the top headers. >>>> { >>>> auto TopHeaders = Mod->getTopHeaders(PP->getFileManager()); >>>> - Record.clear(); >>>> - Record.push_back(SUBMODULE_TOPHEADER); >>>> + RecordData::value_type Record[] = {SUBMODULE_TOPHEADER}; >>>> for (auto *H : TopHeaders) >>>> Stream.EmitRecordWithBlob(TopHeaderAbbrev, Record, >>>> H->getName()); >>>> } >>>> >>>> // Emit the imports. >>>> if (!Mod->Imports.empty()) { >>>> - Record.clear(); >>>> + RecordData Record; >>>> for (auto *I : Mod->Imports) >>>> Record.push_back(getSubmoduleID(I)); >>>> Stream.EmitRecord(SUBMODULE_IMPORTS, Record); >>>> @@ -2553,7 +2521,7 @@ void ASTWriter::WriteSubmodules(Module * >>>> >>>> // Emit the exports. >>>> if (!Mod->Exports.empty()) { >>>> - Record.clear(); >>>> + RecordData Record; >>>> for (const auto &E : Mod->Exports) { >>>> // FIXME: This may fail; we don't require that all exported >>>> modules >>>> // are local or imported. >>>> @@ -2569,26 +2537,23 @@ void ASTWriter::WriteSubmodules(Module * >>>> >>>> // Emit the link libraries. >>>> for (const auto &LL : Mod->LinkLibraries) { >>>> - Record.clear(); >>>> - Record.push_back(SUBMODULE_LINK_LIBRARY); >>>> - Record.push_back(LL.IsFramework); >>>> + RecordData::value_type Record[] = {SUBMODULE_LINK_LIBRARY, >>>> + LL.IsFramework}; >>>> Stream.EmitRecordWithBlob(LinkLibraryAbbrev, Record, LL.Library); >>>> } >>>> >>>> // Emit the conflicts. >>>> for (const auto &C : Mod->Conflicts) { >>>> - Record.clear(); >>>> - Record.push_back(SUBMODULE_CONFLICT); >>>> // FIXME: This may fail; we don't require that all conflicting >>>> modules >>>> // are local or imported. >>>> - Record.push_back(getSubmoduleID(C.Other)); >>>> + RecordData::value_type Record[] = {SUBMODULE_CONFLICT, >>>> + getSubmoduleID(C.Other)}; >>>> Stream.EmitRecordWithBlob(ConflictAbbrev, Record, C.Message); >>>> } >>>> >>>> // Emit the configuration macros. >>>> for (const auto &CM : Mod->ConfigMacros) { >>>> - Record.clear(); >>>> - Record.push_back(SUBMODULE_CONFIG_MACRO); >>>> + RecordData::value_type Record[] = {SUBMODULE_CONFIG_MACRO}; >>>> Stream.EmitRecordWithBlob(ConfigMacroAbbrev, Record, CM); >>>> } >>>> >>>> @@ -2670,8 +2635,6 @@ void ASTWriter::WriteCXXCtorInitializers >>>> if (CXXCtorInitializersOffsets.empty()) >>>> return; >>>> >>>> - RecordData Record; >>>> - >>>> // Create a blob abbreviation for the C++ ctor initializer offsets. >>>> using namespace llvm; >>>> >>>> @@ -2682,9 +2645,8 @@ void ASTWriter::WriteCXXCtorInitializers >>>> unsigned CtorInitializersOffsetAbbrev = Stream.EmitAbbrev(Abbrev); >>>> >>>> // Write the base specifier offsets table. >>>> - Record.clear(); >>>> - Record.push_back(CXX_CTOR_INITIALIZERS_OFFSETS); >>>> - Record.push_back(CXXCtorInitializersOffsets.size()); >>>> + RecordData::value_type Record[] = {CXX_CTOR_INITIALIZERS_OFFSETS, >>>> + >>>> CXXCtorInitializersOffsets.size()}; >>>> Stream.EmitRecordWithBlob(CtorInitializersOffsetAbbrev, Record, >>>> bytes(CXXCtorInitializersOffsets)); >>>> } >>>> @@ -2693,8 +2655,6 @@ void ASTWriter::WriteCXXBaseSpecifiersOf >>>> if (CXXBaseSpecifiersOffsets.empty()) >>>> return; >>>> >>>> - RecordData Record; >>>> - >>>> // Create a blob abbreviation for the C++ base specifiers offsets. >>>> using namespace llvm; >>>> >>>> @@ -2705,9 +2665,8 @@ void ASTWriter::WriteCXXBaseSpecifiersOf >>>> unsigned BaseSpecifierOffsetAbbrev = Stream.EmitAbbrev(Abbrev); >>>> >>>> // Write the base specifier offsets table. >>>> - Record.clear(); >>>> - Record.push_back(CXX_BASE_SPECIFIER_OFFSETS); >>>> - Record.push_back(CXXBaseSpecifiersOffsets.size()); >>>> + RecordData::value_type Record[] = {CXX_BASE_SPECIFIER_OFFSETS, >>>> + CXXBaseSpecifiersOffsets.size()}; >>>> Stream.EmitRecordWithBlob(BaseSpecifierOffsetAbbrev, Record, >>>> bytes(CXXBaseSpecifiersOffsets)); >>>> } >>>> @@ -2778,8 +2737,6 @@ uint64_t ASTWriter::WriteDeclContextLexi >>>> return 0; >>>> >>>> uint64_t Offset = Stream.GetCurrentBitNo(); >>>> - RecordData Record; >>>> - Record.push_back(DECL_CONTEXT_LEXICAL); >>>> SmallVector<uint32_t, 128> KindDeclPairs; >>>> for (const auto *D : DC->decls()) { >>>> KindDeclPairs.push_back(D->getKind()); >>>> @@ -2787,6 +2744,7 @@ uint64_t ASTWriter::WriteDeclContextLexi >>>> } >>>> >>>> ++NumLexicalDeclContexts; >>>> + RecordData::value_type Record[] = {DECL_CONTEXT_LEXICAL}; >>>> Stream.EmitRecordWithBlob(DeclContextLexicalAbbrev, Record, >>>> bytes(KindDeclPairs)); >>>> return Offset; >>>> @@ -2794,7 +2752,6 @@ uint64_t ASTWriter::WriteDeclContextLexi >>>> >>>> void ASTWriter::WriteTypeDeclOffsets() { >>>> using namespace llvm; >>>> - RecordData Record; >>>> >>>> // Write the type offsets array >>>> BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); >>>> @@ -2803,11 +2760,11 @@ void ASTWriter::WriteTypeDeclOffsets() { >>>> Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // base >>>> type index >>>> Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // types block >>>> unsigned TypeOffsetAbbrev = Stream.EmitAbbrev(Abbrev); >>>> - Record.clear(); >>>> - Record.push_back(TYPE_OFFSET); >>>> - Record.push_back(TypeOffsets.size()); >>>> - Record.push_back(FirstTypeID - NUM_PREDEF_TYPE_IDS); >>>> - Stream.EmitRecordWithBlob(TypeOffsetAbbrev, Record, >>>> bytes(TypeOffsets)); >>>> + { >>>> + RecordData::value_type Record[] = {TYPE_OFFSET, TypeOffsets.size(), >>>> + FirstTypeID - >>>> NUM_PREDEF_TYPE_IDS}; >>>> + Stream.EmitRecordWithBlob(TypeOffsetAbbrev, Record, >>>> bytes(TypeOffsets)); >>>> + } >>>> >>>> // Write the declaration offsets array >>>> Abbrev = new BitCodeAbbrev(); >>>> @@ -2816,16 +2773,15 @@ void ASTWriter::WriteTypeDeclOffsets() { >>>> Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // base >>>> decl ID >>>> Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // declarations >>>> block >>>> unsigned DeclOffsetAbbrev = Stream.EmitAbbrev(Abbrev); >>>> - Record.clear(); >>>> - Record.push_back(DECL_OFFSET); >>>> - Record.push_back(DeclOffsets.size()); >>>> - Record.push_back(FirstDeclID - NUM_PREDEF_DECL_IDS); >>>> - Stream.EmitRecordWithBlob(DeclOffsetAbbrev, Record, >>>> bytes(DeclOffsets)); >>>> + { >>>> + RecordData::value_type Record[] = {DECL_OFFSET, DeclOffsets.size(), >>>> + FirstDeclID - >>>> NUM_PREDEF_DECL_IDS}; >>>> + Stream.EmitRecordWithBlob(DeclOffsetAbbrev, Record, >>>> bytes(DeclOffsets)); >>>> + } >>>> } >>>> >>>> void ASTWriter::WriteFileDeclIDsMap() { >>>> using namespace llvm; >>>> - RecordData Record; >>>> >>>> SmallVector<std::pair<FileID, DeclIDInFileInfo *>, 64> >>>> SortedFileDeclIDs( >>>> FileDeclIDs.begin(), FileDeclIDs.end()); >>>> @@ -2846,8 +2802,8 @@ void ASTWriter::WriteFileDeclIDsMap() { >>>> Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); >>>> Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); >>>> unsigned AbbrevCode = Stream.EmitAbbrev(Abbrev); >>>> - Record.push_back(FILE_SORTED_DECLS); >>>> - Record.push_back(FileGroupedDeclIDs.size()); >>>> + RecordData::value_type Record[] = {FILE_SORTED_DECLS, >>>> + FileGroupedDeclIDs.size()}; >>>> Stream.EmitRecordWithBlob(AbbrevCode, Record, >>>> bytes(FileGroupedDeclIDs)); >>>> } >>>> >>>> @@ -3057,11 +3013,11 @@ void ASTWriter::WriteSelectors(Sema &Sem >>>> unsigned MethodPoolAbbrev = Stream.EmitAbbrev(Abbrev); >>>> >>>> // Write the method pool >>>> - RecordData Record; >>>> - Record.push_back(METHOD_POOL); >>>> - Record.push_back(BucketOffset); >>>> - Record.push_back(NumTableEntries); >>>> - Stream.EmitRecordWithBlob(MethodPoolAbbrev, Record, MethodPool); >>>> + { >>>> + RecordData::value_type Record[] = {METHOD_POOL, BucketOffset, >>>> + NumTableEntries}; >>>> + Stream.EmitRecordWithBlob(MethodPoolAbbrev, Record, MethodPool); >>>> + } >>>> >>>> // Create a blob abbreviation for the selector table offsets. >>>> Abbrev = new BitCodeAbbrev(); >>>> @@ -3072,12 +3028,13 @@ void ASTWriter::WriteSelectors(Sema &Sem >>>> unsigned SelectorOffsetAbbrev = Stream.EmitAbbrev(Abbrev); >>>> >>>> // Write the selector offsets table. >>>> - Record.clear(); >>>> - Record.push_back(SELECTOR_OFFSETS); >>>> - Record.push_back(SelectorOffsets.size()); >>>> - Record.push_back(FirstSelectorID - NUM_PREDEF_SELECTOR_IDS); >>>> - Stream.EmitRecordWithBlob(SelectorOffsetAbbrev, Record, >>>> - bytes(SelectorOffsets)); >>>> + { >>>> + RecordData::value_type Record[] = { >>>> + SELECTOR_OFFSETS, SelectorOffsets.size(), >>>> + FirstSelectorID - NUM_PREDEF_SELECTOR_IDS}; >>>> + Stream.EmitRecordWithBlob(SelectorOffsetAbbrev, Record, >>>> + bytes(SelectorOffsets)); >>>> + } >>>> } >>>> } >>>> >>>> @@ -3347,9 +3304,7 @@ void ASTWriter::WriteIdentifierTable(Pre >>>> unsigned IDTableAbbrev = Stream.EmitAbbrev(Abbrev); >>>> >>>> // Write the identifier table >>>> - RecordData Record; >>>> - Record.push_back(IDENTIFIER_TABLE); >>>> - Record.push_back(BucketOffset); >>>> + RecordData::value_type Record[] = {IDENTIFIER_TABLE, BucketOffset}; >>>> Stream.EmitRecordWithBlob(IDTableAbbrev, Record, IdentifierTable); >>>> } >>>> >>>> @@ -3365,11 +3320,10 @@ void ASTWriter::WriteIdentifierTable(Pre >>>> for (unsigned I = 0, N = IdentifierOffsets.size(); I != N; ++I) >>>> assert(IdentifierOffsets[I] && "Missing identifier offset?"); >>>> #endif >>>> - >>>> - RecordData Record; >>>> - Record.push_back(IDENTIFIER_OFFSET); >>>> - Record.push_back(IdentifierOffsets.size()); >>>> - Record.push_back(FirstIdentID - NUM_PREDEF_IDENT_IDS); >>>> + >>>> + RecordData::value_type Record[] = {IDENTIFIER_OFFSET, >>>> + IdentifierOffsets.size(), >>>> + FirstIdentID - >>>> NUM_PREDEF_IDENT_IDS}; >>>> Stream.EmitRecordWithBlob(IdentifierOffsetAbbrev, Record, >>>> bytes(IdentifierOffsets)); >>>> >>>> @@ -3785,8 +3739,7 @@ uint64_t ASTWriter::WriteDeclContextVisi >>>> GenerateNameLookupTable(DC, LookupTable); >>>> >>>> // Write the lookup table >>>> - RecordData Record; >>>> - Record.push_back(DECL_CONTEXT_VISIBLE); >>>> + RecordData::value_type Record[] = {DECL_CONTEXT_VISIBLE}; >>>> Stream.EmitRecordWithBlob(DeclContextVisibleLookupAbbrev, Record, >>>> LookupTable); >>>> ++NumVisibleDeclContexts; >>>> @@ -3817,16 +3770,13 @@ void ASTWriter::WriteDeclContextVisibleU >>>> DC = cast<DeclContext>(Chain->getKeyDeclaration(cast<Decl>(DC))); >>>> >>>> // Write the lookup table >>>> - RecordData Record; >>>> - Record.push_back(UPDATE_VISIBLE); >>>> - Record.push_back(getDeclID(cast<Decl>(DC))); >>>> + RecordData::value_type Record[] = {UPDATE_VISIBLE, >>>> getDeclID(cast<Decl>(DC))}; >>>> Stream.EmitRecordWithBlob(UpdateVisibleAbbrev, Record, LookupTable); >>>> } >>>> >>>> /// \brief Write an FP_PRAGMA_OPTIONS block for the given FPOptions. >>>> void ASTWriter::WriteFPPragmaOptions(const FPOptions &Opts) { >>>> - RecordData Record; >>>> - Record.push_back(Opts.fp_contract); >>>> + RecordData::value_type Record[] = {Opts.fp_contract}; >>>> Stream.EmitRecord(FP_PRAGMA_OPTIONS, Record); >>>> } >>>> >>>> @@ -3883,14 +3833,12 @@ void ASTWriter::WriteObjCCategories() { >>>> Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # of >>>> entries >>>> Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); >>>> unsigned AbbrevID = Stream.EmitAbbrev(Abbrev); >>>> - >>>> - RecordData Record; >>>> - Record.push_back(OBJC_CATEGORIES_MAP); >>>> - Record.push_back(CategoriesMap.size()); >>>> - Stream.EmitRecordWithBlob(AbbrevID, Record, >>>> - >>>> reinterpret_cast<char*>(CategoriesMap.data()), >>>> + >>>> + RecordData::value_type Record[] = {OBJC_CATEGORIES_MAP, >>>> CategoriesMap.size()}; >>>> + Stream.EmitRecordWithBlob(AbbrevID, Record, >>>> + reinterpret_cast<char >>>> *>(CategoriesMap.data()), >>>> CategoriesMap.size() * >>>> sizeof(ObjCCategoriesInfo)); >>>> - >>>> + >>>> // Emit the category lists. >>>> Stream.EmitRecord(OBJC_CATEGORIES, Categories); >>>> } >>>> @@ -3987,7 +3935,7 @@ void ASTWriter::AddPath(StringRef Path, >>>> AddString(FilePath, Record); >>>> } >>>> >>>> -void ASTWriter::EmitRecordWithPath(unsigned Abbrev, RecordDataImpl >>>> &Record, >>>> +void ASTWriter::EmitRecordWithPath(unsigned Abbrev, RecordDataRef >>>> Record, >>>> StringRef Path) { >>>> SmallString<128> FilePath(Path); >>>> PreparePathForOutput(FilePath); >>>> @@ -4250,14 +4198,14 @@ void ASTWriter::WriteASTCore(Sema &SemaR >>>> WriteControlBlock(PP, Context, isysroot, OutputFile); >>>> >>>> // Write the remaining AST contents. >>>> - RecordData Record; >>>> Stream.EnterSubblock(AST_BLOCK_ID, 5); >>>> >>>> // This is so that older clang versions, before the introduction >>>> // of the control block, can read and reject the newer PCH format. >>>> - Record.clear(); >>>> - Record.push_back(VERSION_MAJOR); >>>> - Stream.EmitRecord(METADATA_OLD_FORMAT, Record); >>>> + { >>>> + RecordData Record = {VERSION_MAJOR}; >>>> + Stream.EmitRecord(METADATA_OLD_FORMAT, Record); >>>> + } >>>> >>>> // Create a lexical update block containing all of the declarations >>>> in the >>>> // translation unit that do not come from other AST files. >>>> @@ -4274,11 +4222,12 @@ void ASTWriter::WriteASTCore(Sema &SemaR >>>> Abv->Add(llvm::BitCodeAbbrevOp(TU_UPDATE_LEXICAL)); >>>> Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob)); >>>> unsigned TuUpdateLexicalAbbrev = Stream.EmitAbbrev(Abv); >>>> - Record.clear(); >>>> - Record.push_back(TU_UPDATE_LEXICAL); >>>> - Stream.EmitRecordWithBlob(TuUpdateLexicalAbbrev, Record, >>>> - bytes(NewGlobalKindDeclPairs)); >>>> - >>>> + { >>>> + RecordData::value_type Record[] = {TU_UPDATE_LEXICAL}; >>>> + Stream.EmitRecordWithBlob(TuUpdateLexicalAbbrev, Record, >>>> + bytes(NewGlobalKindDeclPairs)); >>>> + } >>>> + >>>> // And a visible updates block for the translation unit. >>>> Abv = new llvm::BitCodeAbbrev(); >>>> Abv->Add(llvm::BitCodeAbbrevOp(UPDATE_VISIBLE)); >>>> @@ -4408,8 +4357,7 @@ void ASTWriter::WriteASTCore(Sema &SemaR >>>> writeBaseIDOrNone(M->BaseTypeIndex, M->LocalNumTypes); >>>> } >>>> } >>>> - Record.clear(); >>>> - Record.push_back(MODULE_OFFSET_MAP); >>>> + RecordData::value_type Record[] = {MODULE_OFFSET_MAP}; >>>> Stream.EmitRecordWithBlob(ModuleOffsetMapAbbrev, Record, >>>> Buffer.data(), Buffer.size()); >>>> } >>>> @@ -4573,11 +4521,8 @@ void ASTWriter::WriteASTCore(Sema &SemaR >>>> WriteOptimizePragmaOptions(SemaRef); >>>> >>>> // Some simple statistics >>>> - Record.clear(); >>>> - Record.push_back(NumStatements); >>>> - Record.push_back(NumMacros); >>>> - Record.push_back(NumLexicalDeclContexts); >>>> - Record.push_back(NumVisibleDeclContexts); >>>> + RecordData::value_type Record[] = { >>>> + NumStatements, NumMacros, NumLexicalDeclContexts, >>>> NumVisibleDeclContexts}; >>>> Stream.EmitRecord(STATISTICS, Record); >>>> Stream.ExitBlock(); >>>> } >>>> >>>> Modified: cfe/trunk/lib/Serialization/GlobalModuleIndex.cpp >>>> URL: >>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Serialization/GlobalModuleIndex.cpp?rev=247233&r1=247232&r2=247233&view=diff >>>> >>>> ============================================================================== >>>> --- cfe/trunk/lib/Serialization/GlobalModuleIndex.cpp (original) >>>> +++ cfe/trunk/lib/Serialization/GlobalModuleIndex.cpp Wed Sep 9 >>>> 20:46:39 2015 >>>> @@ -757,9 +757,7 @@ void GlobalModuleIndexBuilder::writeInde >>>> unsigned IDTableAbbrev = Stream.EmitAbbrev(Abbrev); >>>> >>>> // Write the identifier table >>>> - Record.clear(); >>>> - Record.push_back(IDENTIFIER_INDEX); >>>> - Record.push_back(BucketOffset); >>>> + uint64_t Record[] = {IDENTIFIER_INDEX, BucketOffset}; >>>> Stream.EmitRecordWithBlob(IDTableAbbrev, Record, IdentifierTable); >>>> } >>>> >>>> >>>> >>>> _______________________________________________ >>>> cfe-commits mailing list >>>> cfe-commits@lists.llvm.org >>>> http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits >>> >>> >> > > _______________________________________________ > cfe-commits mailing list > cfe-commits@lists.llvm.org > http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits > >
_______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits