[llvm] r247898 - Revert "Function bitcode index in Value Symbol Table and lazy reading support"
David Blaikie via llvm-commits
llvm-commits at lists.llvm.org
Thu Sep 17 10:10:11 PDT 2015
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)
- 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
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20150917/ef399c29/attachment.html>
More information about the llvm-commits
mailing list