On Thu, Sep 10, 2015 at 1:34 PM, Richard Smith <rich...@metafoo.co.uk> wrote:
> 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. > Yep, I was slowly getting there. Thanks for the clarity (I don't know the bitcode reader that well, etc) - I imagine the constants used in the init lists are usually int64_t anyway. If you have a literal init list of ints and pass it to a function that takes an initializer_list<uint64_t> do good things happen? or would we have to make sure at least one of the constants is uint64_t? - David > > >> >>>>> — >>>>> 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