r247233 - EmitRecord* API change: accepts ArrayRef instead of a SmallVector (NFC)
Richard Smith via cfe-commits
cfe-commits at lists.llvm.org
Thu Sep 10 18:34:50 PDT 2015
On Thu, Sep 10, 2015 at 6:26 PM, David Blaikie <dblaikie at gmail.com> wrote:
>
>
> On Thu, Sep 10, 2015 at 1:34 PM, Richard Smith <richard at metafoo.co.uk>
> wrote:
>
>> On Thu, Sep 10, 2015 at 11:46 AM, David Blaikie <dblaikie at gmail.com>
>> wrote:
>>
>>>
>>>
>>> On Thu, Sep 10, 2015 at 11:39 AM, Richard Smith <richard at metafoo.co.uk>
>>> wrote:
>>>
>>>> On Thu, Sep 10, 2015 at 9:13 AM, David Blaikie via cfe-commits <
>>>> cfe-commits at lists.llvm.org> wrote:
>>>>
>>>>>
>>>>>
>>>>> On Thu, Sep 10, 2015 at 9:07 AM, Mehdi Amini <mehdi.amini at apple.com>
>>>>> wrote:
>>>>>
>>>>>>
>>>>>> On Sep 10, 2015, at 9:02 AM, David Blaikie <dblaikie at gmail.com>
>>>>>> wrote:
>>>>>>
>>>>>>
>>>>>>
>>>>>> On Thu, Sep 10, 2015 at 9:00 AM, Mehdi Amini <mehdi.amini at apple.com>
>>>>>> wrote:
>>>>>>
>>>>>>>
>>>>>>> On Sep 9, 2015, at 7:06 PM, David Blaikie <dblaikie at gmail.com>
>>>>>>> wrote:
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> On Wed, Sep 9, 2015 at 6:46 PM, Mehdi Amini via cfe-commits <
>>>>>>> cfe-commits at 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.amini at 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 at lists.llvm.org
>>>>>>>> http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
>>>>>>>
>>>>>>>
>>>>>>
>>>>>
>>>>> _______________________________________________
>>>>> cfe-commits mailing list
>>>>> cfe-commits at lists.llvm.org
>>>>> http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
>>>>>
>>>>>
>>>>
>>>
>>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/cfe-commits/attachments/20150910/a8c903eb/attachment-0001.html>
More information about the cfe-commits
mailing list