[wip] Bitcode: Write the irsymtab to disk.

[pcc]

Summary

Fixes PR27551.

This is just to show where I'm going with the irsymtab changes. With this and
its dependencies, no-op incremental ThinLTO link time for Chromium decreases
to about 35s and total .bc file size increases to 1225420580 bytes (versus [0]).

This needs more tests and needs to be split into multiple patches. I also
want to try to shrink the size of the irsymtab further.

[0] http://lists.llvm.org/pipermail/llvm-dev/2017-April/111828.html

Depends on D31838

Depends on D31921

Depends on D31922

[tejohnson]

llvm/include/llvm/Object/IRSymtab.h

131

Does this mean that the symbol table will be thrown away every time the llvm revision changes? Can we avoid that by having a symbol table version number?

llvm/lib/Object/IRSymtab.cpp

332

I guess the disadvantage of having a fully upgradable symbol table is that we can't avoid duplication between the module bitcode and the symbol table. I.e. vs reading the symbol table first, and getting visibility and other symbol info from there and using it in the Module. Although the format if the symbol table is more compressed by not keeping it as structured bitcode records, so it is a tradeoff.

(As an aside - is the linkage type going to be added to the symbol table so that we don't need to parse IR when building the summaries in the bitcode reader?)

I guess the approach of storing the symbol table in a custom string blob was already signed off in D31364, but I'm hoping for another pair of eyes on this. Will add Rafael to the review in case Mehdi doesn't have the bandwidth right now. Especially since we chatted about moving the ThinLTO summaries into this format.

[pcc]

llvm/include/llvm/Object/IRSymtab.h

131

That would be tricky to get right. There are many things that could change the symbol table, even without changing the format.

For example, a change such as D31443 would re-order the symbol table, despite not touching the bitcode reader at all.

As another example, suppose that we decide to remove an intrinsic from LLVM, and we upgrade existing IR by removing the intrinsic declaration (and changing calls to do something else). That by itself would change the symbol table.

So I think the safest option would be to accept only symbol tables from the same revision of LLVM.

llvm/lib/Object/IRSymtab.cpp

332

I guess the disadvantage of having a fully upgradable symbol table is that we can't avoid duplication between the module bitcode and the symbol table. I.e. vs reading the symbol table first, and getting visibility and other symbol info from there and using it in the Module. Although the format if the symbol table is more compressed by not keeping it as structured bitcode records, so it is a tradeoff.

Yes, although to some extent the duplication is unavoidable because we have to be able to store module inline asm symbols here as well.

(As an aside - is the linkage type going to be added to the symbol table so that we don't need to parse IR when building the summaries in the bitcode reader?)

I believe that the only use of the linkage when building the summary is to determine whether a global has external linkage. There is already a symbol flag FB_global that gives us that information.

[tejohnson]

llvm/include/llvm/Object/IRSymtab.h

131

For example, a change such as D31443 would re-order the symbol table, despite not touching the bitcode reader at all.

I guess this makes a different for regularLTO where we need to correlate the symbol resolutions built from the symbol table with the symbols in the module. Presumably it shouldn't matter for something like ThinLTO though, where in the thin link we eventually shouldn't have to look at the module ir at all. Not that this helps much since we don't know the use case. Unfortunate, but I can't think of a way to avoid it offhand, without adding some other way to correlate the module symbols to the symbol table symbols.

llvm/lib/Object/IRSymtab.cpp

332

I believe that the only use of the linkage when building the summary is to determine whether a global has external linkage. There is already a symbol flag FB_global that gives us that information.

Not just that - we need to know the linkage type during the thin link to do weak resolution.

[pcc]

llvm/lib/Object/IRSymtab.cpp

332

You are quite right, I forgot about that. I will take a closer look at that as part of the summary overhaul to see if it can be refactored away.

[mehdi_amini]

llvm/include/llvm/Object/IRSymtab.h

131

So I think the safest option would be to accept only symbol tables from the same revision of LLVM.

But that's a design decision. The symbol table could be stored as bitcode with the same exact restriction as all the usual compatibility, and avoid any duplication with the rest of the module (i.e. not being able to regenerate the symbol table from the rest of the bitcode is *not* a bad thing to me, quite the opposite).
I'm not sure what makes a symbol table "special" here.

[pcc]

llvm/include/llvm/Object/IRSymtab.h

131

Even with a bitcode design that somehow avoided all duplication between the module and the symbol table, I don't see why we wouldn't still have the same set of issues when upgrading old bitcode.

[mehdi_amini]

llvm/include/llvm/Object/IRSymtab.h

131

I don't follow.

[pcc]

llvm/include/llvm/Object/IRSymtab.h

131

The ModuleSymbolTable is the "source of truth" for a module's symbol table, and the irsymtab is effectively a "cache" of the ModuleSymbolTable (an irsymtab is derived from a ModuleSymbolTable). As previously mentioned, a ModuleSymbolTable can change as a result of arbitrary changes to the compiler. The situation we want to avoid is where irsymtab::read gives us a different set of symbols than the ModuleSymbolTable, which could happen if the irsymtab was created using an old version of LLVM. We are robust against such situations by checking the revision number embedded in the bitcode file, and rebuilding the irsymtab if it does not match.

One possible way of being resistant to changes in the symbol table suggests itself: we could discard resolutions for symbols that do not appear in the ModuleSymbolTable, and make up resolutions for symbols that did not appear in the irsymtab. But that doesn't seem particularly sound, because the linker still needs to see the correct set of symbols at symbol resolution time for correctness. To go back to the example where we remove an intrinsic, if the intrinsic is upgraded by replacing it with a call to a runtime library function, this would result in a new undefined symbol in the symbol table. Although we could invent a resolution for it (non-prevailing + non-local + external would do), this new undefined symbol may require the linker to have different behaviour at symbol resolution time. For example, the new undefined symbol may require additional archive members to be loaded, which the linker may not be prepared to do once it has completed LTO. The simplest way to handle that situation is by rebuilding the irsymtab, which would ensure that the undefined symbol is available at symbol resolution time.

[mehdi_amini]

llvm/include/llvm/Object/IRSymtab.h

131

The ModuleSymbolTable is the "source of truth" for a module's symbol table, and the irsymtab is effectively a "cache" of the ModuleSymbolTable (an irsymtab is derived from a ModuleSymbolTable)

Well that is exactly what I qualified right above:

But that's a design decision.

It does not *have to be* this way.

[pcc]

llvm/include/llvm/Object/IRSymtab.h

131

I mean sure, it may be possible to redesign how the bitcode reader works so that the symbol table is implicitly "upgraded" as it is read, and the module bitcode reader uses IR entities derived from the "upgraded" symbol table. That may be something to consider exploring if we ever redesign the bitcode format. My gut feeling, though, is that it would be too complicated to be worth it.

[tejohnson]

llvm/include/llvm/Object/IRSymtab.h

131

Talking through this with pcc this morning, I now tend to agree that it doesn't make sense to optimize for the case where the llvm revision has changed. If the format of the symbol table changes so that fields like linkage, visibility etc are shared between the irsymtab and the IR, then of course it must be kept in sync with the IR at all times. But at least with the format we have in D31364, where the irsymtab is essentially a cache of the symbol information in the module, this seems fine.

Mehdi, do you still have concerns?

[mehdi_amini]

llvm/include/llvm/Object/IRSymtab.h

131

Mehdi, do you still have concerns?

Basically the logic I'm reading here is "the design choice implemented here does not optimize for use-case A so use-case A does not make sense".

This seems completely flawed to me, so I clearly don't understand the reasoning.

[pcc]

llvm/include/llvm/Object/IRSymtab.h

131

The choice being made here is not set in stone. We may decide on a different approach later. But it would be best to consider that orthogonally.

Indeed, if we start with the design that you appear to be advocating, it would not only make the code more complicated, but make it that much more difficult to back out of that decision if it turns out to be wrong, due to the need to continuously support upgrading from the old design. It is not clear to me that a design that avoids duplication like you appear to be proposing would be better because the amount of information being duplicated is, frankly, not large (at least compared to names, which are already being shared) and it is unclear how such a design would address module inline asm symbols.

On the other hand, if the design you are advocating turns out to be better, we can move from this design to that one without the need for upgrade support.

Normally I would expect the consumer's revision to be the same as the producer's, so the need to optimize upgrades does not seem strong. That said, I would be prepared to acknowledge such a need. But there are other ways of optimizing upgrades that do not involve creating compatibility constraints. For example, you can imagine writing upgraded bitcode files (or a marker indicating that the file does not require an upgrade) to the ThinLTO cache directory. So I do not want to make any decisions in this space prematurely.

[pcc]

• Add a missing build dependency
• Add a version number

[pcc]

I have split this change into 6 patches with tests: D33969 D33970 D33971 D33972 D33973 D33974

llvm/include/llvm/Bitcode/BitcodeReader.h

namespace llvm {
 
   template <typename T>
   ErrorOr<T> expectedToErrorOrAndEmitErrors(LLVMContext &Ctx, Expected<T> Val) {
     if (!Val)
       return errorToErrorCodeAndEmitErrors(Ctx, Val.takeError());
     return std::move(*Val);
   }
 
+  struct BitcodeFileContents;
+
   /// Represents a module in a bitcode file.
   class BitcodeModule {
     // This covers the identification (if present) and module blocks.
     ArrayRef<uint8_t> Buffer;
     StringRef ModuleIdentifier;
 
     // The string table used to interpret this module.
     StringRef Strtab;
 
     // The bitstream location of the IDENTIFICATION_BLOCK.
     uint64_t IdentificationBit;
 
     // The bitstream location of this module's MODULE_BLOCK.
     uint64_t ModuleBit;
 
     BitcodeModule(ArrayRef<uint8_t> Buffer, StringRef ModuleIdentifier,
                   uint64_t IdentificationBit, uint64_t ModuleBit)
         : Buffer(Buffer), ModuleIdentifier(ModuleIdentifier),
           IdentificationBit(IdentificationBit), ModuleBit(ModuleBit) {}
 
     // Calls the ctor.
-    friend Expected<std::vector<BitcodeModule>>
-    getBitcodeModuleList(MemoryBufferRef Buffer);
+    friend Expected<BitcodeFileContents>
+    getBitcodeFileContents(MemoryBufferRef Buffer);
 
     Expected<std::unique_ptr<Module>> getModuleImpl(LLVMContext &Context,
                                                     bool MaterializeAll,
                                                     bool ShouldLazyLoadMetadata,
                                                     bool IsImporting);
 
   public:
     StringRef getBuffer() const {
public:
 
     /// Check if the given bitcode buffer contains a summary block.
     Expected<bool> hasSummary();
 
     /// Parse the specified bitcode buffer, returning the module summary index.
     Expected<std::unique_ptr<ModuleSummaryIndex>> getSummary();
   };
 
+  /// Returns the contents of a bitcode file. This includes the raw contents of
+  /// the symbol table embedded in the bitcode file. Clients which require a
+  /// symbol table should prefer to use irsymtab::read instead of this function
+  /// because it creates a reader for the irsymtab and handles upgrading bitcode
+  /// files without a symbol table or with an old symbol table.
+  Expected<BitcodeFileContents> getBitcodeFileContents(MemoryBufferRef Buffer);
+  struct BitcodeFileContents {
+    std::vector<BitcodeModule> Mods;
+    StringRef Symtab, StrtabForSymtab;
+  };
+
   /// Returns a list of modules in the specified bitcode buffer.
   Expected<std::vector<BitcodeModule>>
   getBitcodeModuleList(MemoryBufferRef Buffer);
 
   /// Read the header of the specified bitcode buffer and prepare for lazy
   /// deserialization of function bodies. If ShouldLazyLoadMetadata is true,
   /// lazily load metadata as well. If IsImporting is true, this module is
   /// being parsed for ThinLTO importing into another module.

llvm/include/llvm/Bitcode/BitcodeWriter.h

namespace llvm {
   class Module;
   class raw_ostream;
 
   class BitcodeWriter {
     SmallVectorImpl<char> &Buffer;
     std::unique_ptr<BitstreamWriter> Stream;
 
     StringTableBuilder StrtabBuilder{StringTableBuilder::RAW};
-    bool WroteStrtab = false;
+    BumpPtrAllocator Alloc;
+    bool WroteStrtab = false, WroteSymtab = false;
 
     void writeBlob(unsigned Block, unsigned Record, StringRef Blob);
 
+    std::vector<const Module *> Mods;
+
    public:
     /// Create a BitcodeWriter that writes to Buffer.
     BitcodeWriter(SmallVectorImpl<char> &Buffer);
 
     ~BitcodeWriter();
 
+    /// Attempt to write a symbol table to the bitcode file. This must be called
+    /// at most once after all modules have been written.
+    ///
+    /// A reader does not require a symbol table to interpret a bitcode file;
+    /// the symbol table is needed only to improve link-time performance. So
+    /// this function may decide not to write a symbol table. It may so decide
+    /// if, for example, the target is unregistered or the IR is malformed.
+    void writeSymtab();
+
     /// Write the bitcode file's string table. This must be called exactly once
-    /// after all modules have been written.
+    /// after all modules and the optional symbol table have been written.
     void writeStrtab();
 
     /// Copy the string table for another module into this bitcode file. This
     /// should be called after copying the module itself into the bitcode file.
     void copyStrtab(StringRef Strtab);
 
     /// Write the specified module to the buffer specified at construction time.
     ///
namespace llvm {
   /// is used as the hash instead of computing from the generated bitcode.
   /// Can be used to produce the same module hash for a minimized bitcode
   /// used just for the thin link as in the regular full bitcode that will
   /// be used in the backend.
   void WriteBitcodeToFile(const Module *M, raw_ostream &Out,
                           bool ShouldPreserveUseListOrder = false,
                           const ModuleSummaryIndex *Index = nullptr,
                           bool GenerateHash = false,
-                          ModuleHash *ModHash = nullptr);
+                          ModuleHash *ModHash = nullptr,
+                          bool WriteSymtab = true);
 
   /// Write the specified module summary index to the given raw output stream,
   /// where it will be written in a new bitcode block. This is used when
   /// writing the combined index file for ThinLTO. When writing a subset of the
   /// index for a distributed backend, provide the \p ModuleToSummariesForIndex
   /// map.
   void WriteIndexToFile(const ModuleSummaryIndex &Index, raw_ostream &Out,
                         const std::map<std::string, GVSummaryMapTy>
                             *ModuleToSummariesForIndex = nullptr);
 } // End llvm namespace
 
 #endif

llvm/include/llvm/Bitcode/LLVMBitCodes.h

 
 #ifndef LLVM_BITCODE_LLVMBITCODES_H
 #define LLVM_BITCODE_LLVMBITCODES_H
 
 #include "llvm/Bitcode/BitCodes.h"
 
 namespace llvm {
 namespace bitc {
-// The only top-level block types are MODULE, IDENTIFICATION and STRTAB.
+// The only top-level block types are MODULE, IDENTIFICATION, STRTAB and SYMTAB.
 enum BlockIDs {
   // Blocks
   MODULE_BLOCK_ID = FIRST_APPLICATION_BLOCKID,
 
   // Module sub-block id's.
   PARAMATTR_BLOCK_ID,
   PARAMATTR_GROUP_BLOCK_ID,
 
enum BlockIDs {
   MODULE_STRTAB_BLOCK_ID,
   GLOBALVAL_SUMMARY_BLOCK_ID,
 
   OPERAND_BUNDLE_TAGS_BLOCK_ID,
 
   METADATA_KIND_BLOCK_ID,
 
   STRTAB_BLOCK_ID,
+  SYMTAB_BLOCK_ID,
 };
 
 /// Identification block contains a string that describes the producer details,
 /// and an epoch that defines the auto-upgrade capability.
 enum IdentificationCodes {
   IDENTIFICATION_CODE_STRING = 1, // IDENTIFICATION:      [strchr x N]
   IDENTIFICATION_CODE_EPOCH = 2,  // EPOCH:               [epoch#]
 };
enum ComdatSelectionKindCodes {
   COMDAT_SELECTION_KIND_NO_DUPLICATES = 4,
   COMDAT_SELECTION_KIND_SAME_SIZE = 5,
 };
 
 enum StrtabCodes {
   STRTAB_BLOB = 1,
 };
 
+enum SymtabCodes {
+  SYMTAB_BLOB = 1,
+};
+
 } // End bitc namespace
 } // End llvm namespace
 
 #endif

llvm/include/llvm/Object/IRSymtab.h

 #include "llvm/Support/Error.h"
 #include <cassert>
 #include <cstdint>
 #include <vector>
 
 namespace llvm {
 
 class BitcodeModule;
+class StringTableBuilder;
 
 namespace irsymtab {
 
 namespace storage {
 
 // The data structures in this namespace define the low-level serialization
 // format. Clients that just want to read a symbol table should use the
 // irsymtab::Reader class.
struct Uncommon {
   Word CommonSize, CommonAlign;
 
   /// COFF-specific: the name of the symbol that a weak external resolves to
   /// if not defined.
   Str COFFWeakExternFallbackName;
 };
 
 struct Header {
+  /// Version number of the symtab format. This number should be incremented
+  /// when the format changes, but it does not need to be incremented if a
+  /// change to LLVM would cause it to create a different symbol table.
+  Word Version;
+  enum { kCurrentVersion = 0 };
+
+  /// The producer's version string (LLVM_VERSION_STRING " " LLVM_REVISION).
+  /// Consumers should rebuild the symbol table from IR if the producer's
+  /// version does not match the consumer's version due to potential differences
+  /// in symbol table format, symbol enumeration order and so on.
+  Str Producer;
+
   Range<Module> Modules;
   Range<Comdat> Comdats;
   Range<Symbol> Symbols;
   Range<Uncommon> Uncommons;
 
   Str TargetTriple, SourceFileName;
 
   /// COFF-specific: linker directives.
   Str COFFLinkerOpts;
 };
 
 } // end namespace storage
 
-/// Fills in Symtab and Strtab with a valid symbol and string table for Mods.
-Error build(ArrayRef<Module *> Mods, SmallVector<char, 0> &Symtab,
-            SmallVector<char, 0> &Strtab);
+/// Fills in Symtab and StrtabBuilder with a valid symbol and string table for
+/// Mods.
+Error build(ArrayRef<const Module *> Mods, SmallVector<char, 0> &Symtab,
+            StringTableBuilder &StrtabBuilder, BumpPtrAllocator &Alloc);
 
 /// This represents a symbol that has been read from a storage::Symbol and
 /// possibly a storage::Uncommon.
 struct Symbol {
   // Copied from storage::Symbol.
   StringRef Name, IRName;
   int ComdatIndex;
   uint32_t Flags;
public:
 
   using symbol_range = iterator_range<object::content_iterator<SymbolRef>>;
 
   /// Returns the symbol table for the entire bitcode file.
   /// The symbols enumerated by this method are ephemeral, but they can be
   /// copied into an irsymtab::Symbol object.
   symbol_range symbols() const;
 
+  size_t getNumModules() const { return Modules.size(); }
+
   /// Returns a slice of the symbol table for the I'th module in the file.
   /// The symbols enumerated by this method are ephemeral, but they can be
   /// copied into an irsymtab::Symbol object.
   symbol_range module_symbols(unsigned I) const;
 
   StringRef getTargetTriple() const { return str(header().TargetTriple); }
 
   /// Returns the source file path specified at compile time.

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

 } // end anonymous namespace
 
 static ManagedStatic<BitcodeErrorCategoryType> ErrorCategory;
 
 const std::error_category &llvm::BitcodeErrorCategory() {
   return *ErrorCategory;
 }
 
-static Expected<StringRef> readStrtab(BitstreamCursor &Stream) {
-  if (Stream.EnterSubBlock(bitc::STRTAB_BLOCK_ID))
+static Expected<StringRef> readBlobInRecord(BitstreamCursor &Stream,
+                                            unsigned Block, unsigned RecordID) {
+  if (Stream.EnterSubBlock(Block))
     return error("Invalid record");
 
   StringRef Strtab;
   while (1) {
     BitstreamEntry Entry = Stream.advance();
     switch (Entry.Kind) {
     case BitstreamEntry::EndBlock:
       return Strtab;
 
     case BitstreamEntry::Error:
       return error("Malformed block");
 
     case BitstreamEntry::SubBlock:
       if (Stream.SkipBlock())
         return error("Malformed block");
       break;
 
     case BitstreamEntry::Record:
       StringRef Blob;
       SmallVector<uint64_t, 1> Record;
-      if (Stream.readRecord(Entry.ID, Record, &Blob) == bitc::STRTAB_BLOB)
+      if (Stream.readRecord(Entry.ID, Record, &Blob) == RecordID)
         Strtab = Blob;
       break;
     }
   }
 }
 
 //===----------------------------------------------------------------------===//
 // External interface
 //===----------------------------------------------------------------------===//
 
 Expected<std::vector<BitcodeModule>>
 llvm::getBitcodeModuleList(MemoryBufferRef Buffer) {
+  auto FOrErr = getBitcodeFileContents(Buffer);
+  if (!FOrErr)
+    return FOrErr.takeError();
+  return std::move(FOrErr->Mods);
+}
+
+Expected<BitcodeFileContents>
+llvm::getBitcodeFileContents(MemoryBufferRef Buffer) {
   Expected<BitstreamCursor> StreamOrErr = initStream(Buffer);
   if (!StreamOrErr)
     return StreamOrErr.takeError();
   BitstreamCursor &Stream = *StreamOrErr;
 
-  std::vector<BitcodeModule> Modules;
+  BitcodeFileContents F;
   while (true) {
     uint64_t BCBegin = Stream.getCurrentByteNo();
 
     // We may be consuming bitcode from a client that leaves garbage at the end
     // of the bitcode stream (e.g. Apple's ar tool). If we are close enough to
     // the end that there cannot possibly be another module, stop looking.
     if (BCBegin + 8 >= Stream.getBitcodeBytes().size())
-      return Modules;
+      return F;
+
+    StringRef Symtab, StrtabForSymtab;
 
     BitstreamEntry Entry = Stream.advance();
     switch (Entry.Kind) {
     case BitstreamEntry::EndBlock:
     case BitstreamEntry::Error:
       return error("Malformed block");
 
     case BitstreamEntry::SubBlock: {
case BitstreamEntry::SubBlock: {
           return error("Malformed block");
       }
 
       if (Entry.ID == bitc::MODULE_BLOCK_ID) {
         uint64_t ModuleBit = Stream.GetCurrentBitNo() - BCBegin * 8;
         if (Stream.SkipBlock())
           return error("Malformed block");
 
-        Modules.push_back({Stream.getBitcodeBytes().slice(
-                               BCBegin, Stream.getCurrentByteNo() - BCBegin),
-                           Buffer.getBufferIdentifier(), IdentificationBit,
-                           ModuleBit});
+        F.Mods.push_back({Stream.getBitcodeBytes().slice(
         continue;
       }
 
       if (Entry.ID == bitc::STRTAB_BLOCK_ID) {
-        Expected<StringRef> Strtab = readStrtab(Stream);
+        Expected<StringRef> Strtab =
+            readBlobInRecord(Stream, bitc::STRTAB_BLOCK_ID, bitc::STRTAB_BLOB);
         if (!Strtab)
           return Strtab.takeError();
         // This string table is used by every preceding bitcode module that does
         // not have its own string table. A bitcode file may have multiple
         // string tables if it was created by binary concatenation, for example
         // with "llvm-cat -b".
-        for (auto I = Modules.rbegin(), E = Modules.rend(); I != E; ++I) {
+        for (auto I = F.Mods.rbegin(), E = F.Mods.rend(); I != E; ++I) {
           if (!I->Strtab.empty())
             break;
           I->Strtab = *Strtab;
         }
+        // Similarly, the string table is used by every preceding symbol table;
+        // normally there will be just one.
+        if (!F.Symtab.empty() && F.StrtabForSymtab.empty())
+          F.StrtabForSymtab = *Strtab;
+        continue;
+      }
+
+      if (Entry.ID == bitc::SYMTAB_BLOCK_ID) {
+        Expected<StringRef> SymtabOrErr =
+            readBlobInRecord(Stream, bitc::SYMTAB_BLOCK_ID, bitc::SYMTAB_BLOB);
+        if (!SymtabOrErr)
+          return SymtabOrErr.takeError();
+        if (F.Symtab.empty())
+          F.Symtab = *SymtabOrErr;
         continue;
       }
 
       if (Stream.SkipBlock())
         return error("Malformed block");
       continue;
     }
     case BitstreamEntry::Record:

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

 #include "llvm/IR/Operator.h"
 #include "llvm/IR/UseListOrder.h"
 #include "llvm/IR/ValueSymbolTable.h"
 #include "llvm/MC/StringTableBuilder.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/SHA1.h"
+#include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/Object/IRSymtab.h"
 #include <cctype>
 #include <map>
 using namespace llvm;
 
 namespace {
 
 cl::opt<unsigned>
     IndexThreshold("bitcode-mdindex-threshold", cl::Hidden, cl::init(25),
void BitcodeWriter::writeBlob(unsigned Block, unsigned Record, StringRef Blob) {
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
   auto AbbrevNo = Stream->EmitAbbrev(std::move(Abbv));
 
   Stream->EmitRecordWithBlob(AbbrevNo, ArrayRef<uint64_t>{Record}, Blob);
 
   Stream->ExitBlock();
 }
 
+void BitcodeWriter::writeSymtab() {
+  assert(!WroteStrtab && !WroteSymtab);
+
+  // If any module has module-level inline asm, we will require a registered asm
+  // parser for the target so that we can create an accurate symbol table for
+  // the module.
+  for (const Module *M : Mods) {
+    if (M->getModuleInlineAsm().empty())
+      continue;
+
+    std::string Err;
+    const Triple TT(M->getTargetTriple());
+    const Target *T = TargetRegistry::lookupTarget(TT.str(), Err);
+    if (!T || !T->hasMCAsmParser())
+      return;
+  }
+
+  WroteSymtab = true;
+  SmallVector<char, 0> Symtab;
+  // The irsymtab::build function may be unable to create a symbol table if the
+  // module is malformed (e.g. it contains an invalid alias). Writing a symbol
+  // table is not required for correctness, but we still want to be able to
+  // write malformed modules to bitcode files, so swallow the error.
+  if (Error E = irsymtab::build(Mods, Symtab, StrtabBuilder, Alloc)) {
+    consumeError(std::move(E));
+    return;
+  }
+
+  writeBlob(bitc::SYMTAB_BLOCK_ID, bitc::SYMTAB_BLOB,
+            {Symtab.data(), Symtab.size()});
+}
+
 void BitcodeWriter::writeStrtab() {
   assert(!WroteStrtab);
 
   std::vector<char> Strtab;
   StrtabBuilder.finalizeInOrder();
   Strtab.resize(StrtabBuilder.getSize());
   StrtabBuilder.write((uint8_t *)Strtab.data());
 
   writeBlob(bitc::STRTAB_BLOCK_ID, bitc::STRTAB_BLOB,
             {Strtab.data(), Strtab.size()});
 
   WroteStrtab = true;
 }
 
 void BitcodeWriter::copyStrtab(StringRef Strtab) {
   writeBlob(bitc::STRTAB_BLOCK_ID, bitc::STRTAB_BLOB, Strtab);
   WroteStrtab = true;
 }
 
 void BitcodeWriter::writeModule(const Module *M,
                                 bool ShouldPreserveUseListOrder,
                                 const ModuleSummaryIndex *Index,
                                 bool GenerateHash, ModuleHash *ModHash) {
+  assert(!WroteStrtab);
+
+  Mods.push_back(M);
   ModuleBitcodeWriter ModuleWriter(M, Buffer, StrtabBuilder, *Stream,
                                    ShouldPreserveUseListOrder, Index,
                                    GenerateHash, ModHash);
   ModuleWriter.write();
 }
 
 /// WriteBitcodeToFile - Write the specified module to the specified output
 /// stream.
 void llvm::WriteBitcodeToFile(const Module *M, raw_ostream &Out,
                               bool ShouldPreserveUseListOrder,
                               const ModuleSummaryIndex *Index,
-                              bool GenerateHash, ModuleHash *ModHash) {
+                              bool GenerateHash, ModuleHash *ModHash,
+                              bool WriteSymtab) {
   SmallVector<char, 0> Buffer;
   Buffer.reserve(256*1024);
 
   // If this is darwin or another generic macho target, reserve space for the
   // header.
   Triple TT(M->getTargetTriple());
   if (TT.isOSDarwin() || TT.isOSBinFormatMachO())
     Buffer.insert(Buffer.begin(), BWH_HeaderSize, 0);
 
   BitcodeWriter Writer(Buffer);
   Writer.writeModule(M, ShouldPreserveUseListOrder, Index, GenerateHash,
                      ModHash);
+  if (WriteSymtab)
+    Writer.writeSymtab();
   Writer.writeStrtab();
 
   if (TT.isOSDarwin() || TT.isOSBinFormatMachO())
     emitDarwinBCHeaderAndTrailer(Buffer, TT);
 
   // Write the generated bitstream to "Out".
   Out.write((char*)&Buffer.front(), Buffer.size());
 }

llvm/lib/Object/CMakeLists.txt

add_llvm_library(LLVMObject
   SymbolSize.cpp
   WasmObjectFile.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/Object
 
   DEPENDS
   intrinsics_gen
+  llvm_vcsrevision_h
   )

llvm/lib/Object/IRSymtab.cpp

 #include "llvm/Object/IRObjectFile.h"
 #include "llvm/Object/ModuleSymbolTable.h"
 #include "llvm/Object/SymbolicFile.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/StringSaver.h"
+#include "llvm/Support/VCSRevision.h"
 #include <cassert>
 #include <string>
 #include <utility>
 #include <vector>
 
 using namespace llvm;
 using namespace irsymtab;
 
 namespace {
 
+char kExpectedProducerName[] = LLVM_VERSION_STRING
+#ifdef LLVM_REVISION
+    " " LLVM_REVISION
+#endif
+    ;
+
 /// Stores the temporary state that is required to build an IR symbol table.
 struct Builder {
   SmallVector<char, 0> &Symtab;
-  SmallVector<char, 0> &Strtab;
-
-  Builder(SmallVector<char, 0> &Symtab, SmallVector<char, 0> &Strtab)
-      : Symtab(Symtab), Strtab(Strtab) {}
+  StringTableBuilder &StrtabBuilder;
 
-  StringTableBuilder StrtabBuilder{StringTableBuilder::RAW};
+  Builder(SmallVector<char, 0> &Symtab, StringTableBuilder &StrtabBuilder,
+          BumpPtrAllocator &Alloc)
+      : Symtab(Symtab), StrtabBuilder(StrtabBuilder), Saver(Alloc) {}
 
-  BumpPtrAllocator Alloc;
-  StringSaver Saver{Alloc};
+  StringSaver Saver;
 
   DenseMap<const Comdat *, unsigned> ComdatMap;
   Mangler Mang;
   Triple TT;
 
   std::vector<storage::Comdat> Comdats;
   std::vector<storage::Module> Mods;
   std::vector<storage::Symbol> Syms;
struct Builder {
   template <typename T>
   void writeRange(storage::Range<T> &R, const std::vector<T> &Objs) {
     R.Offset = Symtab.size();
     R.Size = Objs.size();
     Symtab.insert(Symtab.end(), reinterpret_cast<const char *>(Objs.data()),
                   reinterpret_cast<const char *>(Objs.data() + Objs.size()));
   }
 
-  Error addModule(Module *M);
+  Error addModule(const Module *M);
   Error addSymbol(const ModuleSymbolTable &Msymtab,
                   const SmallPtrSet<GlobalValue *, 8> &Used,
                   ModuleSymbolTable::Symbol Sym);
 
-  Error build(ArrayRef<Module *> Mods);
+  Error build(ArrayRef<const Module *> Mods);
 };
 
-Error Builder::addModule(Module *M) {
+Error Builder::addModule(const Module *ConstM) {
+  if (ConstM->getDataLayoutStr().empty())
+    return make_error<StringError>("input module has no datalayout",
+                                   inconvertibleErrorCode());
+
+  // FIXME: Think about const correctness; ModuleSymbolTable and
+  // materializeMetadata need non-const Modules. We can't just propagate const
+  // into ModuleSymbolTable because LTO needs non-const references to
+  // GlobalValues.
+  Module *M = const_cast<Module *>(ConstM);
+
   SmallPtrSet<GlobalValue *, 8> Used;
   collectUsedGlobalVariables(*M, Used, /*CompilerUsed*/ false);
 
   ModuleSymbolTable Msymtab;
   Msymtab.addModule(M);
 
   storage::Module Mod;
   Mod.Begin = Syms.size();
if ((Flags & object::BasicSymbolRef::SF_Weak) &&
       OS.flush();
       setStr(Uncommon().COFFWeakExternFallbackName, Saver.save(FallbackName));
     }
   }
 
   return Error::success();
 }
 
-Error Builder::build(ArrayRef<Module *> IRMods) {
+Error Builder::build(ArrayRef<const Module *> IRMods) {
   storage::Header Hdr;
 
   assert(!IRMods.empty());
+  Hdr.Version = storage::Header::kCurrentVersion;
+  setStr(Hdr.Producer, kExpectedProducerName);
   setStr(Hdr.TargetTriple, IRMods[0]->getTargetTriple());
   setStr(Hdr.SourceFileName, IRMods[0]->getSourceFileName());
   TT = Triple(IRMods[0]->getTargetTriple());
 
   for (auto *M : IRMods)
     if (Error Err = addModule(M))
       return Err;
 
   COFFLinkerOptsOS.flush();
-  setStr(Hdr.COFFLinkerOpts, COFFLinkerOpts);
+  setStr(Hdr.COFFLinkerOpts, Saver.save(COFFLinkerOpts));
 
   // We are about to fill in the header's range fields, so reserve space for it
   // and copy it in afterwards.
   Symtab.resize(sizeof(storage::Header));
   writeRange(Hdr.Modules, Mods);
   writeRange(Hdr.Comdats, Comdats);
   writeRange(Hdr.Symbols, Syms);
   writeRange(Hdr.Uncommons, Uncommons);
 
   *reinterpret_cast<storage::Header *>(Symtab.data()) = Hdr;
-
-  raw_svector_ostream OS(Strtab);
-  StrtabBuilder.finalizeInOrder();
-  StrtabBuilder.write(OS);
-
   return Error::success();
 }
 
 } // end anonymous namespace
 
-Error irsymtab::build(ArrayRef<Module *> Mods, SmallVector<char, 0> &Symtab,
-                      SmallVector<char, 0> &Strtab) {
-  return Builder(Symtab, Strtab).build(Mods);
+Error irsymtab::build(ArrayRef<const Module *> Mods, SmallVector<char, 0> &Symtab,
+                      StringTableBuilder &StrtabBuilder, BumpPtrAllocator &Alloc) {
+  return Builder(Symtab, StrtabBuilder, Alloc).build(Mods);
 }
 
-Expected<File> irsymtab::read(MemoryBufferRef MBRef) {
+// Upgrade a vector of bitcode modules created by an old version of LLVM by
+// creating an irsymtab for them in the current format.
+static Expected<File> upgrade(std::vector<BitcodeModule> BMs) {
   File F;
-  ErrorOr<MemoryBufferRef> BCOrErr =
-      object::IRObjectFile::findBitcodeInMemBuffer(MBRef);
-  if (!BCOrErr)
-    return errorCodeToError(BCOrErr.getError());
-
-  Expected<std::vector<BitcodeModule>> BMsOrErr =
-      getBitcodeModuleList(*BCOrErr);
-  if (!BMsOrErr)
-    return BMsOrErr.takeError();
-
-  if (BMsOrErr->empty())
-    return make_error<StringError>("Bitcode file does not contain any modules",
-                                   inconvertibleErrorCode());
-  F.Mods = std::move(*BMsOrErr);
+  F.Mods = std::move(BMs);
 
   LLVMContext Ctx;
   std::vector<Module *> Mods;
   std::vector<std::unique_ptr<Module>> OwnedMods;
   for (auto BM : F.Mods) {
     Expected<std::unique_ptr<Module>> MOrErr =
         BM.getLazyModule(Ctx, /*ShouldLazyLoadMetadata*/ true,
                          /*IsImporting*/ false);
     if (!MOrErr)
       return MOrErr.takeError();
 
-    if ((*MOrErr)->getDataLayoutStr().empty())
-      return make_error<StringError>("input module has no datalayout",
-                                     inconvertibleErrorCode());
-
     Mods.push_back(MOrErr->get());
     OwnedMods.push_back(std::move(*MOrErr));
   }
 
-  if (Error E = build(Mods, F.Symtab, F.Strtab))
+  StringTableBuilder StrtabBuilder(StringTableBuilder::RAW);
+  BumpPtrAllocator Alloc;
+  if (Error E = build(Mods, F.Symtab, StrtabBuilder, Alloc))
     return std::move(E);
 
+  StrtabBuilder.finalizeInOrder();
+  F.Strtab.resize(StrtabBuilder.getSize());
+  StrtabBuilder.write((uint8_t *)F.Strtab.data());
+
   F.TheReader = {{F.Symtab.data(), F.Symtab.size()},
                  {F.Strtab.data(), F.Strtab.size()}};
   return std::move(F);
 }
+
+Expected<File> irsymtab::read(MemoryBufferRef MBRef) {
+  ErrorOr<MemoryBufferRef> BCOrErr =
+      object::IRObjectFile::findBitcodeInMemBuffer(MBRef);
+  if (!BCOrErr)
+    return errorCodeToError(BCOrErr.getError());
+
+  Expected<BitcodeFileContents> BFCOrErr = getBitcodeFileContents(*BCOrErr);
+  if (!BFCOrErr)
+    return BFCOrErr.takeError();
+  BitcodeFileContents &BFC = *BFCOrErr;
+  if (BFC.Mods.empty())
+    return make_error<StringError>("Bitcode file does not contain any modules",
+                                   inconvertibleErrorCode());
+
+  if (BFC.StrtabForSymtab.empty() ||
+      BFC.Symtab.size() < sizeof(storage::Header))
+    return upgrade(std::move(BFC.Mods));
+
+  // We cannot use the regular reader to read the version and producer, because
+  // it will expect the header to be in the current format. The only thing we
+  // can rely on is that the version and producer will be present as the first
+  // struct elements.
+  auto *Hdr = reinterpret_cast<const storage::Header *>(BFC.Symtab.data());
+  unsigned Version = Hdr->Version;
+  StringRef Producer = Hdr->Producer.get(BFC.StrtabForSymtab);
+  if (Version != storage::Header::kCurrentVersion ||
+      Producer != kExpectedProducerName)
+    return upgrade(std::move(BFC.Mods));
+
+  File F;
+  F.TheReader = {{BFC.Symtab.data(), BFC.Symtab.size()},
+                 {BFC.StrtabForSymtab.data(), BFC.StrtabForSymtab.size()}};
+
+  // Finally, make sure that the number of modules in the symbol table matches
+  // the number of modules in the bitcode file. If they differ, it may mean that
+  // the bitcode file was created by binary concatenation, so we need to create
+  // a new symbol table from scratch.
+  if (F.TheReader.getNumModules() != BFC.Mods.size())
+    return upgrade(std::move(BFC.Mods));
+
+  F.Mods = std::move(BFC.Mods);
+  return std::move(F);
+}

llvm/lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp

void splitAndWriteThinLTOBitcode(
   BitcodeWriter W(Buffer);
   // Save the module hash produced for the full bitcode, which will
   // be used in the backends, and use that in the minimized bitcode
   // produced for the full link.
   ModuleHash ModHash = {{0}};
   W.writeModule(&M, /*ShouldPreserveUseListOrder=*/false, &Index,
                 /*GenerateHash=*/true, &ModHash);
   W.writeModule(MergedM.get());
+  W.writeSymtab();
   W.writeStrtab();
   OS << Buffer;
 
   // If a minimized bitcode module was requested for the thin link,
   // strip the debug info (the merged module was already stripped above)
   // and write it to the given OS.
   if (ThinLinkOS) {
     Buffer.clear();
     BitcodeWriter W2(Buffer);
     StripDebugInfo(M);
     W2.writeModule(&M, /*ShouldPreserveUseListOrder=*/false, &Index,
                    /*GenerateHash=*/false, &ModHash);
     W2.writeModule(MergedM.get());
+    W2.writeSymtab();
     W2.writeStrtab();
     *ThinLinkOS << Buffer;
   }
 }
 
 // Returns whether this module needs to be split because it uses type metadata.
 bool requiresSplit(Module &M) {
   SmallVector<MDNode *, 1> MDs;

llvm/test/Bitcode/invalid.test

 
 FWDREF-TYPE-MISMATCH: Malformed block
 
 RUN: not llvm-dis -disable-output %p/Inputs/invalid-array-element-type.bc 2>&1 | \
 RUN:   FileCheck --check-prefix=ELEMENT-TYPE %s
 RUN: not llvm-dis -disable-output %p/Inputs/invalid-vector-element-type.bc 2>&1 | \
 RUN:   FileCheck --check-prefix=ELEMENT-TYPE %s
 RUN: not llvm-dis -disable-output %p/Inputs/invalid-pointer-element-type.bc 2>&1 | \
-RUN:   FileCheck --check-prefix=ELEMENT-TYPE %s
+RUN:   FileCheck --check-prefix=ELEMENT-TYPE2 %s
 
 ELEMENT-TYPE: Invalid type
+ELEMENT-TYPE2: Invalid record
 
 RUN: not llvm-dis -disable-output %p/Inputs/invalid-cast.bc 2>&1 | \
 RUN:   FileCheck --check-prefix=INVALID-CAST %s
 
 INVALID-CAST: Invalid cast
 
 RUN: not llvm-dis -disable-output %p/Inputs/invalid-array-op-not-2nd-to-last.bc 2>&1 | \
 RUN:   FileCheck --check-prefix=ARRAY-NOT-2LAST %s

llvm/test/Bitcode/thinlto-alias.ll

 ; CHECK:       <GLOBALVAL_SUMMARY_BLOCK
 ; CHECK-NEXT:    <VERSION
 ; See if the call to func is registered.
 ; The value id 1 matches the second FUNCTION record above.
 ; CHECK-NEXT:    <PERMODULE {{.*}} op4=1/>
 ; CHECK-NEXT:  </GLOBALVAL_SUMMARY_BLOCK>
 
 ; CHECK: <STRTAB_BLOCK
-; CHECK-NEXT: blob data = 'mainanalias'
+; CHECK-NEXT: blob data = 'mainanalias{{.*}}'
 
 ; COMBINED:       <GLOBALVAL_SUMMARY_BLOCK
 ; COMBINED-NEXT:    <VERSION
 ; See if the call to analias is registered, using the expected value id.
 ; COMBINED-NEXT:    <VALUE_GUID op0=[[ALIASID:[0-9]+]] op1=-5751648690987223394/>
 ; COMBINED-NEXT:    <VALUE_GUID
 ; COMBINED-NEXT:    <VALUE_GUID op0=[[ALIASEEID:[0-9]+]] op1=-1039159065113703048/>
 ; COMBINED-NEXT:    <COMBINED {{.*}} op5=[[ALIASID]]/>

llvm/test/Bitcode/thinlto-function-summary-callgraph-pgo.ll

 ; "func"
 ; CHECK-NEXT: <FUNCTION op0=4 op1=4
 ; CHECK:       <GLOBALVAL_SUMMARY_BLOCK
 ; CHECK-NEXT:    <VERSION
 ; See if the call to func is registered, using the expected hotness type.
 ; CHECK-NEXT:    <PERMODULE_PROFILE {{.*}} op4=1 op5=2/>
 ; CHECK-NEXT:  </GLOBALVAL_SUMMARY_BLOCK>
 ; CHECK: <STRTAB_BLOCK
-; CHECK-NEXT: blob data = 'mainfunc'
+; CHECK-NEXT: blob data = 'mainfunc{{.*}}'
 
 ; COMBINED:       <GLOBALVAL_SUMMARY_BLOCK
 ; COMBINED-NEXT:    <VERSION
 ; COMBINED-NEXT:    <VALUE_GUID op0=[[FUNCID:[0-9]+]] op1=7289175272376759421/>
 ; COMBINED-NEXT:    <VALUE_GUID
 ; COMBINED-NEXT:    <COMBINED
 ; See if the call to func is registered, using the expected hotness type.
 ; op6=2 which is hotnessType::None.

llvm/test/Bitcode/thinlto-function-summary-callgraph-profile-summary.ll

 ; CHECK-LABEL:       <GLOBALVAL_SUMMARY_BLOCK
 ; CHECK-NEXT:    <VERSION
 ; CHECK-NEXT:    <VALUE_GUID op0=25 op1=123/>
 ; op4=hot1 op6=cold op8=hot2 op10=hot4 op12=none1 op14=hot3 op16=none2 op18=none3 op20=123
 ; CHECK-NEXT:    <PERMODULE_PROFILE {{.*}} op4=1 op5=3 op6=5 op7=1 op8=2 op9=3 op10=4 op11=3 op12=6 op13=2 op14=3 op15=3 op16=7 op17=2 op18=8 op19=2 op20=25 op21=3/>
 ; CHECK-NEXT:  </GLOBALVAL_SUMMARY_BLOCK>
 
 ; CHECK: <STRTAB_BLOCK
-; CHECK-NEXT: blob data = 'hot_functionhot1hot2hot3hot4coldnone1none2none3'
+; CHECK-NEXT: blob data = 'hot_functionhot1hot2hot3hot4coldnone1none2none3{{.*}}'
 
 ; COMBINED:       <GLOBALVAL_SUMMARY_BLOCK
 ; COMBINED-NEXT:    <VERSION
 ; COMBINED-NEXT:    <VALUE_GUID
 ; COMBINED-NEXT:    <VALUE_GUID
 ; COMBINED-NEXT:    <VALUE_GUID
 ; COMBINED-NEXT:    <VALUE_GUID
 ; COMBINED-NEXT:    <VALUE_GUID

llvm/test/Bitcode/thinlto-function-summary-callgraph.ll

 ; "func"
 ; CHECK-NEXT: <FUNCTION op0=4 op1=4
 ; CHECK:       <GLOBALVAL_SUMMARY_BLOCK
 ; CHECK-NEXT:    <VERSION
 ; See if the call to func is registered.
 ; CHECK-NEXT:    <PERMODULE {{.*}} op4=1/>
 ; CHECK-NEXT:  </GLOBALVAL_SUMMARY_BLOCK>
 ; CHECK: <STRTAB_BLOCK
-; CHECK-NEXT: blob data = 'mainfunc'
+; CHECK-NEXT: blob data = 'mainfunc{{.*}}'
 
 
 ; COMBINED:       <GLOBALVAL_SUMMARY_BLOCK
 ; COMBINED-NEXT:    <VERSION
 ; COMBINED-NEXT:    <VALUE_GUID op0=[[FUNCID:[0-9]+]] op1=7289175272376759421/>
 ; COMBINED-NEXT:    <VALUE_GUID
 ; COMBINED-NEXT:    <COMBINED
 ; See if the call to func is registered.

llvm/test/Bitcode/thinlto-function-summary-refgraph.ll

 ; op0=Z op4=func2
 ; CHECK-DAG:    <PERMODULE {{.*}} op0=9 op1=3 {{.*}} op3=0 op4=3/>
 ; Variable bar initialization contains address reference to func:
 ; op0=bar op2=func
 ; CHECK-DAG:    <PERMODULE_GLOBALVAR_INIT_REFS {{.*}} op0=0 op1=0 op2=2/>
 ; CHECK:  </GLOBALVAL_SUMMARY_BLOCK>
 
 ; CHECK: <STRTAB_BLOCK
-; CHECK-NEXT: blob data = 'barglobalvarfuncfunc2foofunc3WXYZllvm.ctpop.i8main'
+; CHECK-NEXT: blob data = 'barglobalvarfuncfunc2foofunc3WXYZllvm.ctpop.i8main{{.*}}'
 
 ; ModuleID = 'thinlto-function-summary-refgraph.ll'
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 @bar = global void (...)* bitcast (void ()* @func to void (...)*), align 8
 
 @globalvar = global i32 0, align 4

llvm/test/Bitcode/thinlto-function-summary.ll

 ; BC-NEXT: <VERSION
 ; BC-NEXT: <PERMODULE {{.*}} op0=1 op1=0
 ; BC-NEXT: <PERMODULE {{.*}} op0=2 op1=0
 ; BC-NEXT: <PERMODULE {{.*}} op0=3 op1=7
 ; BC-NEXT: <PERMODULE {{.*}} op0=4 op1=16
 ; BC-NEXT: <ALIAS {{.*}} op0=5 op1=0 op2=3
 ; BC-NEXT: </GLOBALVAL_SUMMARY_BLOCK
 ; BC: <STRTAB_BLOCK
-; BC-NEXT: blob data = 'hfoobaranon.{{................................}}.0variadicf'
+; BC-NEXT: blob data = 'hfoobaranon.{{................................}}.0variadicf{{.*}}'
 
 
 ; RUN: opt -name-anon-globals -module-summary < %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"

llvm/test/ThinLTO/X86/autoupgrade.ll

 ; Verify that auto-upgrading intrinsics works with Lazy loaded bitcode
 ; Do setup work for all below tests: generate bitcode and combined index
 ; RUN: opt -module-summary %s -o %t.bc
 ; RUN: llvm-lto -thinlto-action=thinlink -o %t3.bc %t.bc %p/Inputs/autoupgrade.bc
 
 ; We can't use llvm-dis here, because it would do the autoupgrade itself.
 
 ; RUN: llvm-link  -summary-index=%t3.bc \
 ; RUN:            -import=globalfunc1:%p/Inputs/autoupgrade.bc %t.bc \
 ; RUN:     | llvm-bcanalyzer -dump | FileCheck %s
 
 ; CHECK: <STRTAB_BLOCK
-; CHECK-NEXT: blob data = 'mainglobalfunc1llvm.invariant.start.p0i8'
+; CHECK-NEXT: blob data = 'mainglobalfunc1llvm.invariant.start.p0i8{{.*}}'
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.11.0"
 
 define i32 @main() #0 {
 entry:
   call void (...) @globalfunc1()
   ret i32 0
 }
 
 declare void @globalfunc1(...) #1