On Thu, Sep 10, 2015 at 11:46 AM, David Blaikie <dblai...@gmail.com> wrote:
> > > 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?) > While the bitstream writer allows any unsigned type, the bitstream reader hardcodes uint64_t, so types larger than uint64_t won't round-trip and don't need to be supported. And we don't need to support smaller types either, because (1) that will cause template argument deduction problems and (2) we are supporting a literal braced-init-list, not some pre-built container of unsigned integers, so it's not really too much of an imposition to perform the conversion to uint64_t in the caller. So hardcoding uint64_t in the writer for the braced-init-list case doesn't seem like a problem to me. > >>>> — >>>> 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
