On Thu, Sep 10, 2015 at 6:26 PM, David Blaikie <dblai...@gmail.com> wrote:
> > > 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? > The initialization of an initializer_list<uint64_t> from an int will implicitly convert all the elements to uint64_t. That said... we are likely to get stung by narrowing conversions here. I guess we can try it and see how bad that problem is. - 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
