[llvm] r247898 - Revert "Function bitcode index in Value Symbol Table and lazy reading support"
Teresa Johnson via llvm-commits
llvm-commits at lists.llvm.org
Thu Sep 17 10:20:33 PDT 2015
On Thu, Sep 17, 2015 at 10:10 AM, David Blaikie <dblaikie at gmail.com> wrote:
>
>
> On Thu, Sep 17, 2015 at 10:10 AM, David Blaikie <dblaikie at gmail.com> wrote:
>>
>>
>>
>> On Thu, Sep 17, 2015 at 10:01 AM, Teresa Johnson <tejohnson at google.com>
>> wrote:
>>>
>>> On Thu, Sep 17, 2015 at 9:34 AM, David Blaikie <dblaikie at gmail.com>
>>> wrote:
>>> >
>>> >
>>> > On Thu, Sep 17, 2015 at 9:19 AM, Teresa Johnson via llvm-commits
>>> > <llvm-commits at lists.llvm.org> wrote:
>>> >>
>>> >> Author: tejohnson
>>> >> Date: Thu Sep 17 11:19:10 2015
>>> >> New Revision: 247898
>>> >>
>>> >> URL: http://llvm.org/viewvc/llvm-project?rev=247898&view=rev
>>> >> Log:
>>> >> Revert "Function bitcode index in Value Symbol Table and lazy reading
>>> >> support"
>>> >>
>>> >> Temporarily revert to fix some buildbot issues. One is a minor issue
>>> >> with a variable unused in NDEBUG mode. More concerning are some test
>>> >> failures on win7 that I need to dig into.
>>> >
>>> >
>>> > Thanks for summarizing the reasons for the revert! (sometimes people
>>> > accidentally skip this step & it makes it difficult to understand/look
>>> > back
>>> > over the history, etc)
>>> >
>>> >>
>>> >> This reverts commit 4e66a74543459832cfd571db42b4543580ae1d1d.
>>> >
>>> >
>>> > We try to use the SVN revision numbers, rather than the git hash, as
>>> > the
>>> > authoritative reference when talking about commits (especially in
>>> > commit
>>> > messages). There's a script (llvm/utils/git-svn/git-svnrevert) to help
>>> > with
>>> > this, that will take a git hash, revert it, but produce a commit
>>> > message
>>> > that includes the svn revision instead of the git hash.
>>>
>>> Ah, thanks for the info. Should I amend the commit message for the
>>> revert?
>>
>>
>> Nothing to do once it's committed upstream - I think in theory there's
>> some way we could setup the SVN permissions to enable this, but it's not the
>> case at the moment at least. No worries - just tips for next time.
>>
>> At least it's helpful to follow up in an email and mention the revision
>> (so searching for the revision finds the email threads, so I'll do that
>> here)
>>
>> This commit reverts r247894
>>
>> (also sometimes helpful to reply to the original commit thread with the
>> inverse email "this patch was reverted in r247898" - so that anyone
>> investigating build bot failures who finds the revision, will immediately
>> know it's been reverted, etc (oh, and include the same blurb you did in this
>> commit message about why it was reverted))
Ok, great. Done. Although read this a little too fast the first time
so I didn't include the full details on why, just that there were
buildbot failures. =/
Thanks,
Teresa
>>
>> - Dave
>>
>>>
>>>
>>> Teresa
>>>
>>> >
>>> > - Dave
>>> >
>>> >>
>>> >>
>>> >> Removed:
>>> >> llvm/trunk/test/Bitcode/vst-forward-declaration.ll
>>> >> Modified:
>>> >> llvm/trunk/include/llvm/Bitcode/LLVMBitCodes.h
>>> >> llvm/trunk/lib/Bitcode/Reader/BitcodeReader.cpp
>>> >> llvm/trunk/lib/Bitcode/Writer/BitcodeWriter.cpp
>>> >> llvm/trunk/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp
>>> >>
>>> >> Modified: llvm/trunk/include/llvm/Bitcode/LLVMBitCodes.h
>>> >> URL:
>>> >>
>>> >> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Bitcode/LLVMBitCodes.h?rev=247898&r1=247897&r2=247898&view=diff
>>> >>
>>> >>
>>> >> ==============================================================================
>>> >> --- llvm/trunk/include/llvm/Bitcode/LLVMBitCodes.h (original)
>>> >> +++ llvm/trunk/include/llvm/Bitcode/LLVMBitCodes.h Thu Sep 17 11:19:10
>>> >> 2015
>>> >> @@ -42,10 +42,7 @@ namespace bitc {
>>> >>
>>> >> TYPE_BLOCK_ID_NEW,
>>> >>
>>> >> - USELIST_BLOCK_ID,
>>> >> -
>>> >> - MODULE_STRTAB_BLOCK_ID,
>>> >> - FUNCTION_SUMMARY_BLOCK_ID
>>> >> + USELIST_BLOCK_ID
>>> >> };
>>> >>
>>> >>
>>> >> @@ -76,8 +73,6 @@ namespace bitc {
>>> >>
>>> >> MODULE_CODE_GCNAME = 11, // GCNAME: [strchr x N]
>>> >> MODULE_CODE_COMDAT = 12, // COMDAT: [selection_kind, name]
>>> >> -
>>> >> - MODULE_CODE_VSTOFFSET = 13, // VSTOFFSET: [offset]
>>> >> };
>>> >>
>>> >> /// PARAMATTR blocks have code for defining a parameter attribute
>>> >> set.
>>> >> @@ -136,11 +131,10 @@ namespace bitc {
>>> >> TST_CODE_ENTRY = 1 // TST_ENTRY: [typeid, namechar x N]
>>> >> };
>>> >>
>>> >> - // Value symbol table codes.
>>> >> + // The value symbol table only has one code (VST_ENTRY_CODE).
>>> >> enum ValueSymtabCodes {
>>> >> - VST_CODE_ENTRY = 1, // VST_ENTRY: [valueid, namechar x N]
>>> >> - VST_CODE_BBENTRY = 2, // VST_BBENTRY: [bbid, namechar x N]
>>> >> - VST_CODE_FNENTRY = 3, // VST_FNENTRY: [valueid, offset,
>>> >> namechar x
>>> >> N]
>>> >> + VST_CODE_ENTRY = 1, // VST_ENTRY: [valid, namechar x N]
>>> >> + VST_CODE_BBENTRY = 2 // VST_BBENTRY: [bbid, namechar x N]
>>> >> };
>>> >>
>>> >> enum MetadataCodes {
>>> >>
>>> >> Modified: llvm/trunk/lib/Bitcode/Reader/BitcodeReader.cpp
>>> >> URL:
>>> >>
>>> >> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Bitcode/Reader/BitcodeReader.cpp?rev=247898&r1=247897&r2=247898&view=diff
>>> >>
>>> >>
>>> >> ==============================================================================
>>> >> --- llvm/trunk/lib/Bitcode/Reader/BitcodeReader.cpp (original)
>>> >> +++ llvm/trunk/lib/Bitcode/Reader/BitcodeReader.cpp Thu Sep 17
>>> >> 11:19:10
>>> >> 2015
>>> >> @@ -147,7 +147,6 @@ class BitcodeReader : public GVMateriali
>>> >> BitstreamCursor Stream;
>>> >> uint64_t NextUnreadBit = 0;
>>> >> bool SeenValueSymbolTable = false;
>>> >> - unsigned VSTOffset = 0;
>>> >>
>>> >> std::vector<Type*> TypeList;
>>> >> BitcodeReaderValueList ValueList;
>>> >> @@ -371,9 +370,7 @@ private:
>>> >> std::error_code parseTypeTable();
>>> >> std::error_code parseTypeTableBody();
>>> >>
>>> >> - ErrorOr<Value *> recordValue(SmallVectorImpl<uint64_t> &Record,
>>> >> - unsigned NameIndex, Triple &TT);
>>> >> - std::error_code parseValueSymbolTable(unsigned Offset = 0);
>>> >> + std::error_code parseValueSymbolTable();
>>> >> std::error_code parseConstants();
>>> >> std::error_code rememberAndSkipFunctionBody();
>>> >> /// Save the positions of the Metadata blocks and skip parsing the
>>> >> blocks.
>>> >> @@ -1586,61 +1583,7 @@ std::error_code BitcodeReader::parseType
>>> >> }
>>> >> }
>>> >>
>>> >> -/// Associate a value with its name from the given index in the
>>> >> provided
>>> >> record.
>>> >> -ErrorOr<Value *> BitcodeReader::recordValue(SmallVectorImpl<uint64_t>
>>> >> &Record,
>>> >> - unsigned NameIndex,
>>> >> Triple
>>> >> &TT) {
>>> >> - SmallString<128> ValueName;
>>> >> - if (convertToString(Record, NameIndex, ValueName))
>>> >> - return error("Invalid record");
>>> >> - unsigned ValueID = Record[0];
>>> >> - if (ValueID >= ValueList.size() || !ValueList[ValueID])
>>> >> - return error("Invalid record");
>>> >> - Value *V = ValueList[ValueID];
>>> >> -
>>> >> - V->setName(StringRef(ValueName.data(), ValueName.size()));
>>> >> - auto *GO = dyn_cast<GlobalObject>(V);
>>> >> - if (GO) {
>>> >> - if (GO->getComdat() == reinterpret_cast<Comdat *>(1)) {
>>> >> - if (TT.isOSBinFormatMachO())
>>> >> - GO->setComdat(nullptr);
>>> >> - else
>>> >> - GO->setComdat(TheModule->getOrInsertComdat(V->getName()));
>>> >> - }
>>> >> - }
>>> >> - return V;
>>> >> -}
>>> >> -
>>> >> -/// Parse the value symbol table at either the current parsing
>>> >> location
>>> >> or
>>> >> -/// at the given bit offset if provided.
>>> >> -std::error_code BitcodeReader::parseValueSymbolTable(unsigned Offset)
>>> >> {
>>> >> - uint64_t CurrentBit;
>>> >> - // Pass in the Offset to distinguish between calling for the
>>> >> module-level
>>> >> - // VST (where we want to jump to the VST offset) and the
>>> >> function-level
>>> >> - // VST (where we don't).
>>> >> - if (Offset > 0) {
>>> >> - // Save the current parsing location so we can jump back at the
>>> >> end
>>> >> - // of the VST read.
>>> >> - CurrentBit = Stream.GetCurrentBitNo();
>>> >> - Stream.JumpToBit(Offset * 32);
>>> >> - BitstreamEntry Entry = Stream.advance();
>>> >> - assert(Entry.Kind == BitstreamEntry::SubBlock);
>>> >> - assert(Entry.ID == bitc::VALUE_SYMTAB_BLOCK_ID);
>>> >> - }
>>> >> -
>>> >> - // Compute the delta between the bitcode indices in the VST (the
>>> >> word
>>> >> offset
>>> >> - // to the word-aligned ENTER_SUBBLOCK for the function block, and
>>> >> that
>>> >> - // expected by the lazy reader. The reader's EnterSubBlock expects
>>> >> to
>>> >> have
>>> >> - // already read the ENTER_SUBBLOCK code (size getAbbrevIDWidth) and
>>> >> BlockID
>>> >> - // (size BlockIDWidth). Note that we access the stream's AbbrevID
>>> >> width
>>> >> here
>>> >> - // just before entering the VST subblock because: 1) the
>>> >> EnterSubBlock
>>> >> - // changes the AbbrevID width; 2) the VST block is nested within
>>> >> the
>>> >> same
>>> >> - // outer MODULE_BLOCK as the FUNCTION_BLOCKs and therefore have the
>>> >> same
>>> >> - // AbbrevID width before calling EnterSubBlock; and 3) when we want
>>> >> to
>>> >> - // jump to the FUNCTION_BLOCK using this offset later, we don't
>>> >> want
>>> >> - // to rely on the stream's AbbrevID width being that of the
>>> >> MODULE_BLOCK.
>>> >> - unsigned FuncBitcodeOffsetDelta =
>>> >> - Stream.getAbbrevIDWidth() + bitc::BlockIDWidth;
>>> >> -
>>> >> +std::error_code BitcodeReader::parseValueSymbolTable() {
>>> >> if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID))
>>> >> return error("Invalid record");
>>> >>
>>> >> @@ -1658,8 +1601,6 @@ std::error_code BitcodeReader::parseValu
>>> >> case BitstreamEntry::Error:
>>> >> return error("Malformed block");
>>> >> case BitstreamEntry::EndBlock:
>>> >> - if (Offset > 0)
>>> >> - Stream.JumpToBit(CurrentBit);
>>> >> return std::error_code();
>>> >> case BitstreamEntry::Record:
>>> >> // The interesting case.
>>> >> @@ -1672,39 +1613,23 @@ std::error_code BitcodeReader::parseValu
>>> >> default: // Default behavior: unknown type.
>>> >> break;
>>> >> case bitc::VST_CODE_ENTRY: { // VST_ENTRY: [valueid, namechar x
>>> >> N]
>>> >> - ErrorOr<Value *> ValOrErr = recordValue(Record, 1, TT);
>>> >> - if (std::error_code EC = ValOrErr.getError())
>>> >> - return EC;
>>> >> - ValOrErr.get();
>>> >> - break;
>>> >> - }
>>> >> - case bitc::VST_CODE_FNENTRY: {
>>> >> - // VST_FNENTRY: [valueid, offset, namechar x N]
>>> >> - ErrorOr<Value *> ValOrErr = recordValue(Record, 2, TT);
>>> >> - if (std::error_code EC = ValOrErr.getError())
>>> >> - return EC;
>>> >> - Value *V = ValOrErr.get();
>>> >> + if (convertToString(Record, 1, ValueName))
>>> >> + return error("Invalid record");
>>> >> + unsigned ValueID = Record[0];
>>> >> + if (ValueID >= ValueList.size() || !ValueList[ValueID])
>>> >> + return error("Invalid record");
>>> >> + Value *V = ValueList[ValueID];
>>> >>
>>> >> - auto *GO = dyn_cast<GlobalObject>(V);
>>> >> - if (!GO) {
>>> >> - // If this is an alias, need to get the actual Function
>>> >> object
>>> >> - // it aliases, in order to set up the DeferredFunctionInfo
>>> >> entry
>>> >> below.
>>> >> - auto *GA = dyn_cast<GlobalAlias>(V);
>>> >> - if (GA)
>>> >> - GO = GA->getBaseObject();
>>> >> - assert(GO);
>>> >> - }
>>> >> -
>>> >> - uint64_t FuncWordOffset = Record[1];
>>> >> - Function *F = dyn_cast<Function>(GO);
>>> >> - assert(F);
>>> >> - uint64_t FuncBitOffset = FuncWordOffset * 32;
>>> >> - DeferredFunctionInfo[F] = FuncBitOffset +
>>> >> FuncBitcodeOffsetDelta;
>>> >> - // Set the NextUnreadBit to point to the last function block.
>>> >> - // Later when parsing is resumed after function
>>> >> materialization,
>>> >> - // we can simply skip that last function block.
>>> >> - if (FuncBitOffset > NextUnreadBit)
>>> >> - NextUnreadBit = FuncBitOffset;
>>> >> + V->setName(StringRef(ValueName.data(), ValueName.size()));
>>> >> + if (auto *GO = dyn_cast<GlobalObject>(V)) {
>>> >> + if (GO->getComdat() == reinterpret_cast<Comdat *>(1)) {
>>> >> + if (TT.isOSBinFormatMachO())
>>> >> + GO->setComdat(nullptr);
>>> >> + else
>>> >> +
>>> >> GO->setComdat(TheModule->getOrInsertComdat(V->getName()));
>>> >> + }
>>> >> + }
>>> >> + ValueName.clear();
>>> >> break;
>>> >> }
>>> >> case bitc::VST_CODE_BBENTRY: {
>>> >> @@ -2927,23 +2852,9 @@ std::error_code BitcodeReader::parseModu
>>> >> return EC;
>>> >> break;
>>> >> case bitc::VALUE_SYMTAB_BLOCK_ID:
>>> >> - if (!SeenValueSymbolTable) {
>>> >> - // Either this is an old form VST without function index
>>> >> and an
>>> >> - // associated VST forward declaration record (which would
>>> >> have
>>> >> caused
>>> >> - // the VST to be jumped to and parsed before it was
>>> >> encountered
>>> >> - // normally in the stream), or there were no function
>>> >> blocks to
>>> >> - // trigger an earlier parsing of the VST.
>>> >> - assert(VSTOffset == 0 || FunctionsWithBodies.empty());
>>> >> - if (std::error_code EC = parseValueSymbolTable())
>>> >> - return EC;
>>> >> - SeenValueSymbolTable = true;
>>> >> - } else {
>>> >> - // We must have had a VST forward declaration record, which
>>> >> caused
>>> >> - // the parser to jump to and parse the VST earlier.
>>> >> - assert(VSTOffset > 0);
>>> >> - if (Stream.SkipBlock())
>>> >> - return error("Invalid record");
>>> >> - }
>>> >> + if (std::error_code EC = parseValueSymbolTable())
>>> >> + return EC;
>>> >> + SeenValueSymbolTable = true;
>>> >> break;
>>> >> case bitc::CONSTANTS_BLOCK_ID:
>>> >> if (std::error_code EC = parseConstants())
>>> >> @@ -2971,32 +2882,6 @@ std::error_code BitcodeReader::parseModu
>>> >> SeenFirstFunctionBody = true;
>>> >> }
>>> >>
>>> >> - if (VSTOffset > 0) {
>>> >> - // If we have a VST forward declaration record, make sure
>>> >> we
>>> >> - // parse the VST now if we haven't already. It is needed to
>>> >> - // set up the DeferredFunctionInfo vector for lazy reading.
>>> >> - if (!SeenValueSymbolTable) {
>>> >> - if (std::error_code EC =
>>> >> - BitcodeReader::parseValueSymbolTable(VSTOffset))
>>> >> - return EC;
>>> >> - SeenValueSymbolTable = true;
>>> >> - return std::error_code();
>>> >> - } else {
>>> >> - // If we have a VST forward declaration record, but have
>>> >> already
>>> >> - // parsed the VST (just above, when the first function
>>> >> body
>>> >> was
>>> >> - // encountered here), then we are resuming the parse
>>> >> after
>>> >> - // materializing functions. The NextUnreadBit points to
>>> >> the
>>> >> start
>>> >> - // of the last function block recorded in the VST (set
>>> >> when
>>> >> - // parsing the VST function entries). Skip it.
>>> >> - if (Stream.SkipBlock())
>>> >> - return error("Invalid record");
>>> >> - continue;
>>> >> - }
>>> >> - }
>>> >> -
>>> >> - // Support older bitcode files that did not have the function
>>> >> - // index in the VST, nor a VST forward declaration record.
>>> >> - // Build the DeferredFunctionInfo vector on the fly.
>>> >> if (std::error_code EC = rememberAndSkipFunctionBody())
>>> >> return EC;
>>> >> // Suspend parsing when we reach the function bodies.
>>> >> Subsequent
>>> >> @@ -3300,12 +3185,6 @@ std::error_code BitcodeReader::parseModu
>>> >> return error("Invalid record");
>>> >> ValueList.shrinkTo(Record[0]);
>>> >> break;
>>> >> - /// MODULE_CODE_VSTOFFSET: [offset]
>>> >> - case bitc::MODULE_CODE_VSTOFFSET:
>>> >> - if (Record.size() < 1)
>>> >> - return error("Invalid record");
>>> >> - VSTOffset = Record[0];
>>> >> - break;
>>> >> }
>>> >> Record.clear();
>>> >> }
>>> >> @@ -4763,11 +4642,6 @@ std::error_code BitcodeReader::findFunct
>>> >> Function *F,
>>> >> DenseMap<Function *, uint64_t>::iterator
>>> >> DeferredFunctionInfoIterator) {
>>> >> while (DeferredFunctionInfoIterator->second == 0) {
>>> >> - // This is the fallback handling for the old format bitcode that
>>> >> - // didn't contain the function index in the VST. Assert if we end
>>> >> up
>>> >> - // here for the new format (which is the only time the VSTOffset
>>> >> would
>>> >> - // be non-zero).
>>> >> - assert(VSTOffset == 0);
>>> >> if (Stream.AtEndOfStream())
>>> >> return error("Could not find function in stream");
>>> >> // ParseModule will parse the next body in the stream and set its
>>> >>
>>> >> Modified: llvm/trunk/lib/Bitcode/Writer/BitcodeWriter.cpp
>>> >> URL:
>>> >>
>>> >> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Bitcode/Writer/BitcodeWriter.cpp?rev=247898&r1=247897&r2=247898&view=diff
>>> >>
>>> >>
>>> >> ==============================================================================
>>> >> --- llvm/trunk/lib/Bitcode/Writer/BitcodeWriter.cpp (original)
>>> >> +++ llvm/trunk/lib/Bitcode/Writer/BitcodeWriter.cpp Thu Sep 17
>>> >> 11:19:10
>>> >> 2015
>>> >> @@ -574,40 +574,10 @@ static void writeComdats(const ValueEnum
>>> >> }
>>> >> }
>>> >>
>>> >> -/// Write a record that will eventually hold the word offset of the
>>> >> -/// module-level VST. For now the offset is 0, which will be
>>> >> backpatched
>>> >> -/// after the real VST is written. Returns the bit offset to
>>> >> backpatch.
>>> >> -static uint64_t WriteValueSymbolTableForwardDecl(const
>>> >> ValueSymbolTable
>>> >> &VST,
>>> >> - BitstreamWriter
>>> >> &Stream)
>>> >> {
>>> >> - if (VST.empty()) return 0;
>>> >> -
>>> >> - // Write a placeholder value in for the offset of the real VST,
>>> >> - // which is written after the function blocks so that it can
>>> >> include
>>> >> - // the offset of each function. The placeholder offset will be
>>> >> - // updated when the real VST is written.
>>> >> - BitCodeAbbrev *Abbv = new BitCodeAbbrev();
>>> >> - Abbv->Add(BitCodeAbbrevOp(bitc::MODULE_CODE_VSTOFFSET));
>>> >> - // Blocks are 32-bit aligned, so we can use a 32-bit word offset to
>>> >> - // hold the real VST offset. Must use fixed instead of VBR as we
>>> >> don't
>>> >> - // know how many VBR chunks to reserve ahead of time.
>>> >> - Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
>>> >> - unsigned VSTOffsetAbbrev = Stream.EmitAbbrev(Abbv);
>>> >> -
>>> >> - // Emit the placeholder
>>> >> - ArrayRef<unsigned> Vals = {llvm::bitc::MODULE_CODE_VSTOFFSET, 0};
>>> >> - Stream.EmitRecordWithAbbrev(VSTOffsetAbbrev, Vals);
>>> >> -
>>> >> - // Compute and return the bit offset to the placeholder, which will
>>> >> be
>>> >> - // patched when the real VST is written. We can simply subtract the
>>> >> 32-bit
>>> >> - // fixed size from the current bit number to get the location to
>>> >> backpatch.
>>> >> - return Stream.GetCurrentBitNo() - 32;
>>> >> -}
>>> >> -
>>> >> -/// Emit top-level description of module, including target triple,
>>> >> inline
>>> >> asm,
>>> >> -/// descriptors for global variables, and function prototype info.
>>> >> -/// Returns the bit offset to backpatch with the location of the real
>>> >> VST.
>>> >> -static uint64_t WriteModuleInfo(const Module *M, const
>>> >> ValueEnumerator
>>> >> &VE,
>>> >> - BitstreamWriter &Stream) {
>>> >> +// Emit top-level description of module, including target triple,
>>> >> inline
>>> >> asm,
>>> >> +// descriptors for global variables, and function prototype info.
>>> >> +static void WriteModuleInfo(const Module *M, const ValueEnumerator
>>> >> &VE,
>>> >> + BitstreamWriter &Stream) {
>>> >> // Emit various pieces of data attached to a module.
>>> >> if (!M->getTargetTriple().empty())
>>> >> WriteStringRecord(bitc::MODULE_CODE_TRIPLE, M->getTargetTriple(),
>>> >> @@ -767,10 +737,6 @@ static uint64_t WriteModuleInfo(const Mo
>>> >> Stream.EmitRecord(bitc::MODULE_CODE_ALIAS, Vals, AbbrevToUse);
>>> >> Vals.clear();
>>> >> }
>>> >> -
>>> >> - uint64_t VSTOffsetPlaceholder =
>>> >> - WriteValueSymbolTableForwardDecl(M->getValueSymbolTable(),
>>> >> Stream);
>>> >> - return VSTOffsetPlaceholder;
>>> >> }
>>> >>
>>> >> static uint64_t GetOptimizationFlags(const Value *V) {
>>> >> @@ -2125,119 +2091,32 @@ static StringEncoding getStringEncoding(
>>> >> return SE_Fixed7;
>>> >> }
>>> >>
>>> >> -/// Emit names for globals/functions etc. The VSTOffsetPlaceholder,
>>> >> -/// BitcodeStartBit and FunctionIndex are only passed for the
>>> >> module-level
>>> >> -/// VST, where we are including a function bitcode index and need to
>>> >> -/// backpatch the VST forward declaration record.
>>> >> -static void WriteValueSymbolTable(
>>> >> - const ValueSymbolTable &VST, const ValueEnumerator &VE,
>>> >> - BitstreamWriter &Stream, uint64_t VSTOffsetPlaceholder = 0,
>>> >> - uint64_t BitcodeStartBit = 0,
>>> >> - DenseMap<const Function *, uint64_t> *FunctionIndex = nullptr) {
>>> >> - if (VST.empty()) {
>>> >> - // WriteValueSymbolTableForwardDecl should have returned early as
>>> >> - // well. Ensure this handling remains in sync by asserting that
>>> >> - // the placeholder offset is not set.
>>> >> - assert(VSTOffsetPlaceholder == 0);
>>> >> - return;
>>> >> - }
>>> >> -
>>> >> - if (VSTOffsetPlaceholder > 0) {
>>> >> - // Get the offset of the VST we are writing, and backpatch it
>>> >> into
>>> >> - // the VST forward declaration record.
>>> >> - uint64_t VSTOffset = Stream.GetCurrentBitNo();
>>> >> - // The BitcodeStartBit was the stream offset of the actual
>>> >> bitcode
>>> >> - // (e.g. excluding any initial darwin header).
>>> >> - VSTOffset -= BitcodeStartBit;
>>> >> - assert((VSTOffset & 31) == 0 && "VST block not 32-bit aligned");
>>> >> - Stream.BackpatchWord(VSTOffsetPlaceholder, VSTOffset / 32);
>>> >> - }
>>> >> -
>>> >> +// Emit names for globals/functions etc.
>>> >> +static void WriteValueSymbolTable(const ValueSymbolTable &VST,
>>> >> + const ValueEnumerator &VE,
>>> >> + BitstreamWriter &Stream) {
>>> >> + if (VST.empty()) return;
>>> >> Stream.EnterSubblock(bitc::VALUE_SYMTAB_BLOCK_ID, 4);
>>> >>
>>> >> - // For the module-level VST, add abbrev Ids for the
>>> >> VST_CODE_FNENTRY
>>> >> - // records, which are not used in the per-function VSTs.
>>> >> - unsigned FnEntry8BitAbbrev;
>>> >> - unsigned FnEntry7BitAbbrev;
>>> >> - unsigned FnEntry6BitAbbrev;
>>> >> - if (VSTOffsetPlaceholder > 0) {
>>> >> - // 8-bit fixed-width VST_FNENTRY function strings.
>>> >> - BitCodeAbbrev *Abbv = new BitCodeAbbrev();
>>> >> - Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_FNENTRY));
>>> >> - Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // value id
>>> >> - Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); //
>>> >> funcoffset
>>> >> - Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
>>> >> - Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8));
>>> >> - FnEntry8BitAbbrev = Stream.EmitAbbrev(Abbv);
>>> >> -
>>> >> - // 7-bit fixed width VST_FNENTRY function strings.
>>> >> - Abbv = new BitCodeAbbrev();
>>> >> - Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_FNENTRY));
>>> >> - Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // value id
>>> >> - Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); //
>>> >> funcoffset
>>> >> - Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
>>> >> - Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7));
>>> >> - FnEntry7BitAbbrev = Stream.EmitAbbrev(Abbv);
>>> >> -
>>> >> - // 6-bit char6 VST_FNENTRY function strings.
>>> >> - Abbv = new BitCodeAbbrev();
>>> >> - Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_FNENTRY));
>>> >> - Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // value id
>>> >> - Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); //
>>> >> funcoffset
>>> >> - Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
>>> >> - Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6));
>>> >> - FnEntry6BitAbbrev = Stream.EmitAbbrev(Abbv);
>>> >> - }
>>> >> -
>>> >> // FIXME: Set up the abbrev, we know how many values there are!
>>> >> // FIXME: We know if the type names can use 7-bit ascii.
>>> >> SmallVector<unsigned, 64> NameVals;
>>> >>
>>> >> for (const ValueName &Name : VST) {
>>> >> +
>>> >> // Figure out the encoding to use for the name.
>>> >> StringEncoding Bits =
>>> >> getStringEncoding(Name.getKeyData(), Name.getKeyLength());
>>> >>
>>> >> unsigned AbbrevToUse = VST_ENTRY_8_ABBREV;
>>> >> - NameVals.push_back(VE.getValueID(Name.getValue()));
>>> >> -
>>> >> - Function *F = dyn_cast<Function>(Name.getValue());
>>> >> - if (!F) {
>>> >> - // If value is an alias, need to get the aliased base object to
>>> >> - // see if it is a function.
>>> >> - auto *GA = dyn_cast<GlobalAlias>(Name.getValue());
>>> >> - if (GA && GA->getBaseObject())
>>> >> - F = dyn_cast<Function>(GA->getBaseObject());
>>> >> - }
>>> >>
>>> >> // VST_ENTRY: [valueid, namechar x N]
>>> >> - // VST_FNENTRY: [valueid, funcoffset, namechar x N]
>>> >> // VST_BBENTRY: [bbid, namechar x N]
>>> >> unsigned Code;
>>> >> if (isa<BasicBlock>(Name.getValue())) {
>>> >> Code = bitc::VST_CODE_BBENTRY;
>>> >> if (Bits == SE_Char6)
>>> >> AbbrevToUse = VST_BBENTRY_6_ABBREV;
>>> >> - } else if (F && !F->isDeclaration()) {
>>> >> - // Must be the module-level VST, where we pass in the Index and
>>> >> - // have a VSTOffsetPlaceholder. The function-level VST should
>>> >> not
>>> >> - // contain any Function symbols.
>>> >> - assert(FunctionIndex);
>>> >> - assert(VSTOffsetPlaceholder > 0);
>>> >> -
>>> >> - // Save the word offset of the function (from the start of the
>>> >> - // actual bitcode written to the stream).
>>> >> - assert(FunctionIndex->count(F) == 1);
>>> >> - uint64_t BitcodeIndex = (*FunctionIndex)[F] - BitcodeStartBit;
>>> >> - assert((BitcodeIndex & 31) == 0 && "function block not 32-bit
>>> >> aligned");
>>> >> - NameVals.push_back(BitcodeIndex / 32);
>>> >> -
>>> >> - Code = bitc::VST_CODE_FNENTRY;
>>> >> - AbbrevToUse = FnEntry8BitAbbrev;
>>> >> - if (Bits == SE_Char6)
>>> >> - AbbrevToUse = FnEntry6BitAbbrev;
>>> >> - else if (Bits == SE_Fixed7)
>>> >> - AbbrevToUse = FnEntry7BitAbbrev;
>>> >> } else {
>>> >> Code = bitc::VST_CODE_ENTRY;
>>> >> if (Bits == SE_Char6)
>>> >> @@ -2246,6 +2125,7 @@ static void WriteValueSymbolTable(
>>> >> AbbrevToUse = VST_ENTRY_7_ABBREV;
>>> >> }
>>> >>
>>> >> + NameVals.push_back(VE.getValueID(Name.getValue()));
>>> >> for (const char *P = Name.getKeyData(),
>>> >> *E = Name.getKeyData()+Name.getKeyLength(); P != E; ++P)
>>> >> NameVals.push_back((unsigned char)*P);
>>> >> @@ -2293,13 +2173,7 @@ static void WriteUseListBlock(const Func
>>> >>
>>> >> /// WriteFunction - Emit a function body to the module stream.
>>> >> static void WriteFunction(const Function &F, ValueEnumerator &VE,
>>> >> - BitstreamWriter &Stream,
>>> >> - DenseMap<const Function *, uint64_t>
>>> >> &FunctionIndex) {
>>> >> - // Save the bitcode index of the start of this function block for
>>> >> recording
>>> >> - // in the VST.
>>> >> - uint64_t BitcodeIndex = Stream.GetCurrentBitNo();
>>> >> - FunctionIndex[&F] = BitcodeIndex;
>>> >> -
>>> >> + BitstreamWriter &Stream) {
>>> >> Stream.EnterSubblock(bitc::FUNCTION_BLOCK_ID, 4);
>>> >> VE.incorporateFunction(F);
>>> >>
>>> >> @@ -2547,8 +2421,7 @@ static void WriteBlockInfo(const ValueEn
>>> >>
>>> >> /// WriteModule - Emit the specified module to the bitstream.
>>> >> static void WriteModule(const Module *M, BitstreamWriter &Stream,
>>> >> - bool ShouldPreserveUseListOrder,
>>> >> - uint64_t BitcodeStartBit) {
>>> >> + bool ShouldPreserveUseListOrder) {
>>> >> Stream.EnterSubblock(bitc::MODULE_BLOCK_ID, 3);
>>> >>
>>> >> SmallVector<unsigned, 1> Vals;
>>> >> @@ -2575,7 +2448,7 @@ static void WriteModule(const Module *M,
>>> >>
>>> >> // Emit top-level description of module, including target triple,
>>> >> inline asm,
>>> >> // descriptors for global variables, and function prototype info.
>>> >> - uint64_t VSTOffsetPlaceholder = WriteModuleInfo(M, VE, Stream);
>>> >> + WriteModuleInfo(M, VE, Stream);
>>> >>
>>> >> // Emit constants.
>>> >> WriteModuleConstants(VE, Stream);
>>> >> @@ -2586,18 +2459,17 @@ static void WriteModule(const Module *M,
>>> >> // Emit metadata.
>>> >> WriteModuleMetadataStore(M, Stream);
>>> >>
>>> >> + // Emit names for globals/functions etc.
>>> >> + WriteValueSymbolTable(M->getValueSymbolTable(), VE, Stream);
>>> >> +
>>> >> // Emit module-level use-lists.
>>> >> if (VE.shouldPreserveUseListOrder())
>>> >> WriteUseListBlock(nullptr, VE, Stream);
>>> >>
>>> >> // Emit function bodies.
>>> >> - DenseMap<const Function *, uint64_t> FunctionIndex;
>>> >> for (Module::const_iterator F = M->begin(), E = M->end(); F != E;
>>> >> ++F)
>>> >> if (!F->isDeclaration())
>>> >> - WriteFunction(*F, VE, Stream, FunctionIndex);
>>> >> -
>>> >> - WriteValueSymbolTable(M->getValueSymbolTable(), VE, Stream,
>>> >> - VSTOffsetPlaceholder, BitcodeStartBit,
>>> >> &FunctionIndex);
>>> >> + WriteFunction(*F, VE, Stream);
>>> >>
>>> >> Stream.ExitBlock();
>>> >> }
>>> >> @@ -2688,11 +2560,6 @@ void llvm::WriteBitcodeToFile(const Modu
>>> >> // Emit the module into the buffer.
>>> >> {
>>> >> BitstreamWriter Stream(Buffer);
>>> >> - // Save the start bit of the actual bitcode, in case there is
>>> >> space
>>> >> - // saved at the start for the darwin header above. The reader
>>> >> stream
>>> >> - // will start at the bitcode, and we need the offset of the VST
>>> >> - // to line up.
>>> >> - uint64_t BitcodeStartBit = Stream.GetCurrentBitNo();
>>> >>
>>> >> // Emit the file header.
>>> >> Stream.Emit((unsigned)'B', 8);
>>> >> @@ -2703,7 +2570,7 @@ void llvm::WriteBitcodeToFile(const Modu
>>> >> Stream.Emit(0xD, 4);
>>> >>
>>> >> // Emit the module.
>>> >> - WriteModule(M, Stream, ShouldPreserveUseListOrder,
>>> >> BitcodeStartBit);
>>> >> + WriteModule(M, Stream, ShouldPreserveUseListOrder);
>>> >> }
>>> >>
>>> >> if (TT.isOSDarwin())
>>> >>
>>> >> Removed: llvm/trunk/test/Bitcode/vst-forward-declaration.ll
>>> >> URL:
>>> >>
>>> >> http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Bitcode/vst-forward-declaration.ll?rev=247897&view=auto
>>> >>
>>> >>
>>> >> ==============================================================================
>>> >> --- llvm/trunk/test/Bitcode/vst-forward-declaration.ll (original)
>>> >> +++ llvm/trunk/test/Bitcode/vst-forward-declaration.ll (removed)
>>> >> @@ -1,29 +0,0 @@
>>> >> -; RUN: llvm-as < %s | llvm-bcanalyzer -dump | FileCheck %s
>>> >> -check-prefix=BC
>>> >> -; Check for VST forward declaration record and VST function index
>>> >> records.
>>> >> -
>>> >> -; BC: <VSTOFFSET
>>> >> -; BC: <FNENTRY
>>> >> -; BC: <FNENTRY
>>> >> -
>>> >> -; RUN: llvm-as < %s | llvm-dis | FileCheck %s
>>> >> -; Check that this round-trips correctly.
>>> >> -
>>> >> -; ModuleID = '<stdin>'
>>> >> -target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
>>> >> -target triple = "x86_64-unknown-linux-gnu"
>>> >> -
>>> >> -; CHECK: define i32 @foo()
>>> >> -
>>> >> -; Function Attrs: nounwind uwtable
>>> >> -define i32 @foo() #0 {
>>> >> -entry:
>>> >> - ret i32 1
>>> >> -}
>>> >> -
>>> >> -; CHECK: define i32 @bar(i32 %x)
>>> >> -
>>> >> -; Function Attrs: nounwind uwtable
>>> >> -define i32 @bar(i32 %x) #0 {
>>> >> -entry:
>>> >> - ret i32 %x
>>> >> -}
>>> >>
>>> >> Modified: llvm/trunk/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp
>>> >> URL:
>>> >>
>>> >> http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp?rev=247898&r1=247897&r2=247898&view=diff
>>> >>
>>> >>
>>> >> ==============================================================================
>>> >> --- llvm/trunk/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp (original)
>>> >> +++ llvm/trunk/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp Thu Sep 17
>>> >> 11:19:10 2015
>>> >> @@ -165,7 +165,6 @@ static const char *GetCodeName(unsigned
>>> >> STRINGIFY_CODE(MODULE_CODE, ALIAS)
>>> >> STRINGIFY_CODE(MODULE_CODE, PURGEVALS)
>>> >> STRINGIFY_CODE(MODULE_CODE, GCNAME)
>>> >> - STRINGIFY_CODE(MODULE_CODE, VSTOFFSET)
>>> >> }
>>> >> case bitc::PARAMATTR_BLOCK_ID:
>>> >> switch (CodeID) {
>>> >> @@ -267,7 +266,6 @@ static const char *GetCodeName(unsigned
>>> >> default: return nullptr;
>>> >> STRINGIFY_CODE(VST_CODE, ENTRY)
>>> >> STRINGIFY_CODE(VST_CODE, BBENTRY)
>>> >> - STRINGIFY_CODE(VST_CODE, FNENTRY)
>>> >> }
>>> >> case bitc::METADATA_ATTACHMENT_ID:
>>> >> switch(CodeID) {
>>> >>
>>> >>
>>> >> _______________________________________________
>>> >> llvm-commits mailing list
>>> >> llvm-commits at lists.llvm.org
>>> >> http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits
>>> >
>>> >
>>>
>>>
>>>
>>> --
>>> Teresa Johnson | Software Engineer | tejohnson at google.com | 408-460-2413
>>
>>
>
--
Teresa Johnson | Software Engineer | tejohnson at google.com | 408-460-2413
More information about the llvm-commits
mailing list