On Thu, Sep 10, 2015 at 11:39 AM, Richard Smith <rich...@metafoo.co.uk> wrote:
> 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. > Ah, good to know - thanks for the catch. > 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>. > Except the integer types aren't known - which has been one of the wrinkles with this whole code (or at least the template is trying to allow arrays of different integer types - but perhaps that's not important for the init list/literal case?) > > >>> — >>> 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
