[ThinLTO] Bitcode reading/writing support for ThinLTO function summary/index

[tejohnson]

Summary

This patch adds bitcode reading/writing support for the ThinLTO function summary/index in bitcode. Some of the support is currently stubbed out (e.g. the records within the ThinLTO blocks), pending comments on the associated file format RFC.

The ThinLTO data structures are defined in http://reviews.llvm.org/D11721.

Related RFCs:
RFC: ThinLTO File Format (http://lists.cs.uiuc.edu/pipermail/llvmdev/2015-August/088947.html)
RFC: ThinLTO File API and Data Structures (http://lists.cs.uiuc.edu/pipermail/llvmdev/2015-August/088951.html)

[tejohnson]

Updated the patch to use the parameter defined under -fthinlto in pending patch http://reviews.llvm.org/D11907. Added the same reviewers to this patch.

[reames]

Can you add references to the relevant RFCs to the review descriptions? It's getting hard to track all the pieces. My main comments can be found in the linked review for the data structures.

include/llvm/Bitcode/ReaderWriter.h

70

As a general comment: this index really isn't a ThinkLTO*Index, it's a *Index for the bitcode that happens to be used for LTO. The naming of the various methods and comments need to reflect that.

[tejohnson]

In D11722#223090, @reames wrote:

Can you add references to the relevant RFCs to the review descriptions? It's getting hard to track all the pieces. My main comments can be found in the linked review for the data structures.

Will do.

include/llvm/Bitcode/ReaderWriter.h

70

I responded to this suggestion in the review for D11721 as well - I didn't think this information would be used outside of ThinLTO importing decisions/mechanics. So thought it was better to name it accordingly. I'm open to changing the name, which currently also matches the names of the proposed bitcode sections.

[tejohnson]

Removed native object wrapper support from this patch.

[davidxl]

include/llvm/Bitcode/ReaderWriter.h

73

Add a comment here to make it clear that lazy summary parsing is needed for reading combined index in the function import phase.

77

Make the comment clearer that:

1. When reading combined index (ThinLTOSummaryIndex), getThinLTOIndex is first called with ParseFuncSummary=false
2. The method supports lazily reading Function summary data associated for the function specified by the function name.

78

Should it really be 'readThinLTOFunctionSummary'?

lib/Bitcode/Reader/BitcodeReader.cpp

425

parseBitcodeInto sounds too generic. Perhaps parseSummaryIndex?

427

Is it better to call it 'parseFunctionSummary'? Also move this interface decl after parseThinLTOSummary() below to show their order in the parsing hierarchy.

431

Do these parsing interfaces need to be public, other than the top level parseBitcodeInto and the lazy reading parseFunction?

433

Is it clearer to call it

parseThinLTOSummaries or parseThinLTOSummaryBlock?

437

parseBitCodeInto is a top level interface which is basically a wrapper to parseModule after seeking to the start of module block -- so it seems that parseModule can be inlined into parseBitcodeInto to avoid confusion.

4737

Add comment about the purpose of the function.

4803

Reorder this case to reflect the physical order of block ids on disk?

4988

It is more readable to have a helper function to do 'seekToModuleStart' which includes the loop, and move the parseModule outside of it.

5276

Suggested comment:

Otherwise skip the function summary section, but only create an index object with a map from function name to function summary offset. The index is used to perform lazy function summary reading later.

5331

FunctionSummaryOffset?

[tejohnson]

Responses and some other comments below. New patch being uploaded shortly.

include/llvm/Bitcode/ReaderWriter.h

78

Yes, changed.

lib/Bitcode/Reader/BitcodeReader.cpp

425

Since it mirrors BitcodeReader::parseBitcodeInto, I will change this to parseSummaryIndexInto.

427

Changed the name. Can't move after parseThinLTOSummary since this one needs to be public and I am making the other one private (see below). Instead added a comment about it being used to read a function summary entry lazily.

431

Moved all of these parseThinLTO* routines into the private section.

433

Changed to parseEntireThinLTOSummary.

437

I prefer to keep the current division as it mirrors how parseBitcodeInto/parseModule are structured in the normal BilcodeReader.

4988

I purposely structured this the same way as the corresponding BitcodeReader::parseBitcodeInto() function.

5251

Inlined into getThinLTOIndex since that was the only caller.

5286

Inlined into hasThinLTOIndex since that was the only caller.

5312

Inlined into readThinLTOFunctionInfo since that was the only caller.

5325

I have replaced this TODO with the code.

[tejohnson]

Changes based on review David's review comments. I also added lots of other comments, and replaced a TODO in readThinLTOFunctionSummary to actually walk through the infos for a function name and access the saved summary offset.

[tejohnson]

Obsolete. New patch is http://reviews.llvm.org/D13107

include/llvm/Bitcode/LLVMBitCodes.h

enum BlockIDs {
     UNUSED_ID1,
 
     VALUE_SYMTAB_BLOCK_ID,
     METADATA_BLOCK_ID,
     METADATA_ATTACHMENT_ID,
 
     TYPE_BLOCK_ID_NEW,
 
-    USELIST_BLOCK_ID
+    USELIST_BLOCK_ID,
+
+    THINLTO_BLOCK_ID,
+
+    // ThinLTO sub-block id's.
+    THINLTO_SYMTAB_BLOCK_ID,
+    THINLTO_MODULE_STRTAB_BLOCK_ID,
+    THINLTO_FUNCTION_SUMMARY_BLOCK_ID
   };
 
 
   /// MODULE blocks have a number of optional fields and subblocks.
   enum ModuleCodes {
     MODULE_CODE_VERSION     = 1,    // VERSION:     [version#]
     MODULE_CODE_TRIPLE      = 2,    // TRIPLE:      [strchr x N]
     MODULE_CODE_DATALAYOUT  = 3,    // DATALAYOUT:  [strchr x N]

include/llvm/Bitcode/ReaderWriter.h

 // This header defines interfaces to read and write LLVM bitcode files/streams.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_BITCODE_READERWRITER_H
 #define LLVM_BITCODE_READERWRITER_H
 
 #include "llvm/IR/DiagnosticInfo.h"
+#include "llvm/IR/ThinLTOInfo.h"
+#include "llvm/MC/MCStreamer.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include <memory>
 #include <string>
 
 namespace llvm {
   class BitstreamWriter;
namespace llvm {
   getBitcodeTargetTriple(MemoryBufferRef Buffer, LLVMContext &Context,
                          DiagnosticHandlerFunction DiagnosticHandler = nullptr);
 
   /// Read the specified bitcode file, returning the module.
   ErrorOr<std::unique_ptr<Module>>
   parseBitcodeFile(MemoryBufferRef Buffer, LLVMContext &Context,
                    DiagnosticHandlerFunction DiagnosticHandler = nullptr);
 
+  /// Check if the given bitcode buffer contains a ThinLTO block.
+  bool hasThinLTOIndex(MemoryBufferRef Buffer, LLVMContext &Context,
+                       DiagnosticHandlerFunction DiagnosticHandler);
+
+  /// Parse the specified bitcode buffer, returning the ThinLTO index.
+  /// If ParseFuncSummary is true, parse the entire function summary into
+  /// the index, otherwise skip the function summary section.
+  ErrorOr<std::unique_ptr<ThinLTOFunctionSummaryIndex>> getThinLTOIndex(
+      MemoryBufferRef Buffer, LLVMContext &Context,
+      DiagnosticHandlerFunction DiagnosticHandler,
+      bool ParseFuncSummary = true);
+
+  /// Parse the given function summary and module strings bitcode buffers,
+  /// returning the ThinLTO index constructed using the given ThinLTO
+  /// function map. This interface is used in the native object wrapped
+  /// case, where the function map is constructed from the object's symbol
+  /// table. If ParseFuncSummary is true, parse the entire function summary into
+  /// the index, otherwise the summary buffer is ignored and may be empty.
+  ErrorOr<std::unique_ptr<ThinLTOFunctionSummaryIndex>> getThinLTOIndex(
+      MemoryBufferRef SummaryBuffer, MemoryBufferRef ModStringsBuffer,
+      std::unique_ptr<ThinLTOFunctionMap> FuncMap, LLVMContext &Context,
+      DiagnosticHandlerFunction DiagnosticHandler,
+      bool ParseFuncSummary = true);
+
+  /// Parse the summary information for the given function name into
+  /// the given index. This is used when we already parsed the rest of
+  /// the index with getThinLTOIndex and ParseFuncSummary=false.
+  /// It handles both the bitcode-only and native-object wrapped bitcode
+  /// cases.
+  std::error_code readThinLTOFunctionInfo(
+      MemoryBufferRef Buffer, LLVMContext &Context,
+      DiagnosticHandlerFunction DiagnosticHandler, StringRef FunctionName,
+      std::unique_ptr<ThinLTOFunctionSummaryIndex> Index);
+
   /// \brief Write the specified module to the specified raw output stream.
   ///
   /// For streams where it matters, the given stream should be in "binary"
   /// mode.
   ///
   /// If \c ShouldPreserveUseListOrder, encode the use-list order for each \a
   /// Value in \c M.  These will be reconstructed exactly when \a M is
   /// deserialized.
   void WriteBitcodeToFile(const Module *M, raw_ostream &Out,
                           bool ShouldPreserveUseListOrder = false);
 
+  // Write the specified module to the given target specific streamer,
+  // where it will be wrapped in an .llvmbc section.
+  void WriteModuleToStreamer(const Module *M, MCStreamer &MCS);
+
+  // Write the specified ThinLTO 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.
+  void WriteThinLTOToFile(const ThinLTOFunctionSummaryIndex *Index,
+                          raw_ostream &Out);
+
+  // Write the specified ThinLTO index to the given target specific
+  // streamer, where it will be wrapped in native object sections.
+  void WriteThinLTOToStreamer(const ThinLTOFunctionSummaryIndex *Index,
+                              MCStreamer &MCS);
+
   /// isBitcodeWrapper - Return true if the given bytes are the magic bytes
   /// for an LLVM IR bitcode wrapper.
   ///
   inline bool isBitcodeWrapper(const unsigned char *BufPtr,
                                const unsigned char *BufEnd) {
     // See if you can find the hidden message in the magic bytes :-).
     // (Hint: it's a little-endian encoding.)
     return BufPtr != BufEnd &&

lib/Bitcode/Reader/BitcodeReader.cpp

 #include "llvm/IR/DiagnosticPrinter.h"
 #include "llvm/IR/GVMaterializer.h"
 #include "llvm/IR/InlineAsm.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/OperandTraits.h"
 #include "llvm/IR/Operator.h"
+#include "llvm/IR/ThinLTOInfo.h"
 #include "llvm/IR/ValueHandle.h"
 #include "llvm/Support/DataStream.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/raw_ostream.h"
 #include <deque>
 using namespace llvm;
private:
   std::error_code parseUseLists();
   std::error_code initStream(std::unique_ptr<DataStreamer> Streamer);
   std::error_code initStreamFromBuffer();
   std::error_code initLazyStream(std::unique_ptr<DataStreamer> Streamer);
   std::error_code findFunctionInStream(
       Function *F,
       DenseMap<Function *, uint64_t>::iterator DeferredFunctionInfoIterator);
 };
+
+// Class to manage readig and parsing ThinLTO bitcode files/sections.
+class ThinLTOBitcodeReader {
+  LLVMContext &Context;
+  DiagnosticHandlerFunction DiagnosticHandler;
+  ThinLTOFunctionSummaryIndex *TheIndex = nullptr;
+  std::unique_ptr<MemoryBuffer> Buffer;
+  std::unique_ptr<BitstreamReader> StreamFile;
+  BitstreamCursor Stream;
+  uint64_t NextUnreadBit = 0;
+  bool SeenValueSymbolTable = false;
+  bool SeenThinLTO = false;
+  bool ParseFuncSummaryData = true;
+  bool CheckThinLTOPresenceOnly = false;
+  bool BufferContainsFuncSummaryDataOnly = false;
+  // The type of bitcode buffer we are reading, specifically, the bitcode
+  // block id of the expected outermost ThinLTO block. Default is
+  // a full THINLTO_BLOCK, which is the bitcode-only file case.
+  // For native-wrapped bitcode this could be either a THINLTO_SUMMARY_BLOCK
+  // or a THINLTO_MODULE_STRTAB_BLOCK.
+  unsigned BufferType = bitc::THINLTO_BLOCK_ID;
+  // Map built from the ThinLTO-specific value symbol table parser,
+  // which holds mapping from the value ID to the name, since the ThinLTO
+  // symbol table references the value ID for function names.
+  StringMap<unsigned> ValueSymtab;
+
+public:
+  std::error_code error(BitcodeError E, const Twine &Message);
+  std::error_code error(BitcodeError E);
+  std::error_code error(const Twine &Message);
+
+  ThinLTOBitcodeReader(MemoryBuffer *Buffer, LLVMContext &Context,
+                       DiagnosticHandlerFunction DiagnosticHandler,
+                       bool ParseFuncSummary = true,
+                       bool CheckPresenceOnly = false,
+                       unsigned BuffType = bitc::THINLTO_BLOCK_ID);
+  ThinLTOBitcodeReader(LLVMContext &Context,
+                       DiagnosticHandlerFunction DiagnosticHandler,
+                       bool ParseFuncSummary = true,
+                       bool CheckPresenceOnly = false,
+                       unsigned BuffType = bitc::THINLTO_BLOCK_ID);
+  ~ThinLTOBitcodeReader() { freeState(); }
+
+  void freeState();
+
+  void releaseBuffer();
+
+  bool foundThinLTO() {
+    return SeenThinLTO;
+  }
+
+  /// \brief Main interface to parsing a bitcode buffer.
+  /// \returns true if an error occurred.
+  std::error_code parseBitcodeInto(std::unique_ptr<DataStreamer> Streamer,
+                                   ThinLTOFunctionSummaryIndex *I);
+  std::error_code parseFunction(std::unique_ptr<DataStreamer> Streamer,
+                                ThinLTOFunctionSummaryIndex *I,
+                                size_t FunctionOffset);
+
+  std::error_code parseThinLTOBlock();
+  std::error_code parseThinLTOSymtab();
+  std::error_code parseThinLTOSummary();
+  std::error_code parseThinLTOModuleStringTable();
+
+private:
+  std::error_code parseModule();
+  std::error_code parseValueSymbolTable();
+  std::error_code initStream(std::unique_ptr<DataStreamer> Streamer);
+  std::error_code initStreamFromBuffer();
+  std::error_code initLazyStream(std::unique_ptr<DataStreamer> Streamer);
+};
 } // namespace
 
 BitcodeDiagnosticInfo::BitcodeDiagnosticInfo(std::error_code EC,
                                              DiagnosticSeverity Severity,
                                              const Twine &Msg)
     : DiagnosticInfo(DK_Bitcode, Severity), Msg(Msg), EC(EC) {}
 
 void BitcodeDiagnosticInfo::print(DiagnosticPrinter &DP) const { DP << Msg; }
if (isBitcodeWrapper(buf, buf + 4)) {
     const unsigned char *bitcodeEnd = buf + 16;
     SkipBitcodeWrapperHeader(bitcodeStart, bitcodeEnd, false);
     Bytes.dropLeadingBytes(bitcodeStart - buf);
     Bytes.setKnownObjectSize(bitcodeEnd - bitcodeStart);
   }
   return std::error_code();
 }
 
+std::error_code ThinLTOBitcodeReader::error(BitcodeError E,
+                                            const Twine &Message) {
+  return ::error(DiagnosticHandler, make_error_code(E), Message);
+}
+
+std::error_code ThinLTOBitcodeReader::error(const Twine &Message) {
+  return ::error(DiagnosticHandler,
+                 make_error_code(BitcodeError::CorruptedBitcode), Message);
+}
+
+std::error_code ThinLTOBitcodeReader::error(BitcodeError E) {
+  return ::error(DiagnosticHandler, make_error_code(E));
+}
+
+ThinLTOBitcodeReader::ThinLTOBitcodeReader(
+    MemoryBuffer *Buffer, LLVMContext &Context,
+    DiagnosticHandlerFunction DiagnosticHandler,
+    bool ParseFuncSummary, bool CheckPresenceOnly,
+    unsigned BuffType)
+    : Context(Context),
+      DiagnosticHandler(getDiagHandler(DiagnosticHandler, Context)),
+      Buffer(Buffer),
+      ParseFuncSummaryData(ParseFuncSummary),
+      CheckThinLTOPresenceOnly(CheckPresenceOnly),
+      BufferType(BuffType) {}
+
+ThinLTOBitcodeReader::ThinLTOBitcodeReader(LLVMContext &Context,
+                             DiagnosticHandlerFunction DiagnosticHandler,
+                             bool ParseFuncSummary, bool CheckPresenceOnly,
+                             unsigned BuffType)
+    : Context(Context),
+      DiagnosticHandler(getDiagHandler(DiagnosticHandler, Context)),
+      Buffer(nullptr),
+      ParseFuncSummaryData(ParseFuncSummary),
+      CheckThinLTOPresenceOnly(CheckPresenceOnly),
+      BufferType(BuffType) {}
+
+void ThinLTOBitcodeReader::freeState() {
+  Buffer = nullptr;
+}
+
+void ThinLTOBitcodeReader::releaseBuffer() { Buffer.release(); }
+
+// Specialized value symbol table parser used when reading ThinLTO
+// blocks where we don't actually create global values.
+std::error_code ThinLTOBitcodeReader::parseValueSymbolTable() {
+  if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID))
+    return error("Invalid record");
+
+  SmallVector<uint64_t, 64> Record;
+
+  // Read all the records for this value table.
+  SmallString<128> ValueName;
+  while (1) {
+    BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
+
+    switch (Entry.Kind) {
+    case BitstreamEntry::SubBlock: // Handled for us already.
+    case BitstreamEntry::Error:
+      return error("Malformed block");
+    case BitstreamEntry::EndBlock:
+      return std::error_code();
+    case BitstreamEntry::Record:
+      // The interesting case.
+      break;
+    }
+
+    // Read a record.
+    Record.clear();
+    switch (Stream.readRecord(Entry.ID, Record)) {
+      default:  // Default behavior: ignore (e.g. VST_CODE_BBENTRY records).
+        break;
+      case bitc::VST_CODE_ENTRY: {  // VST_ENTRY: [valueid, namechar x N]
+        if (convertToString(Record, 1, ValueName))
+          return error("Invalid record");
+        unsigned ValueID = Record[0];
+        ValueSymtab.insert(std::make_pair(
+            StringRef(ValueName.data(), ValueName.size()), ValueID));
+        ValueName.clear();
+        break;
+      }
+    }
+  }
+}
+
+std::error_code ThinLTOBitcodeReader::parseModule() {
+  if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))
+    return error("Invalid record");
+
+  // Read the ThinLTO records for this module.
+  while (1) {
+    BitstreamEntry Entry = Stream.advance();
+
+    switch (Entry.Kind) {
+    case BitstreamEntry::Error:
+      return error("Malformed block");
+    case BitstreamEntry::EndBlock:
+      return std::error_code();
+
+    case BitstreamEntry::SubBlock:
+      switch (Entry.ID) {
+      default:  // Skip unknown content.
+        if (Stream.SkipBlock())
+          return error("Invalid record");
+        break;
+      case bitc::BLOCKINFO_BLOCK_ID:
+        // Need to parse these to get abbrev ids (e.g. for VST)
+        if (Stream.ReadBlockInfoBlock())
+          return error("Malformed block");
+        break;
+      case bitc::THINLTO_BLOCK_ID:
+        //errs() << "parseModule found THINLTO_BLOCK_ID\n";
+        assert(SeenValueSymbolTable);
+        SeenThinLTO = true;
+        if (CheckThinLTOPresenceOnly) {
+          if (Stream.SkipBlock())
+            return error("Invalid record");
+        }
+        else if (std::error_code EC = parseThinLTOBlock())
+          return EC;
+        break;
+      case bitc::VALUE_SYMTAB_BLOCK_ID:
+        //errs() << "parseModule found VALUE_SYMTAB_BLOCK_ID\n";
+        assert(!SeenValueSymbolTable);
+        SeenValueSymbolTable = true;
+        if (CheckThinLTOPresenceOnly) {
+          if (Stream.SkipBlock())
+            return error("Invalid record");
+        }
+        else if (std::error_code EC = parseValueSymbolTable())
+          return EC;
+        break;
+      }
+      continue;
+
+    case BitstreamEntry::Record:
+      Stream.skipRecord(Entry.ID);
+      continue;
+    }
+  }
+}
+
+std::error_code ThinLTOBitcodeReader::parseThinLTOBlock() {
+  if (Stream.EnterSubBlock(bitc::THINLTO_BLOCK_ID))
+    return error("Invalid record");
+
+  while (1) {
+    BitstreamEntry Entry = Stream.advance();
+
+    switch (Entry.Kind) {
+    case BitstreamEntry::Error:
+      return error("Malformed block");
+    case BitstreamEntry::EndBlock:
+      return std::error_code();
+
+    case BitstreamEntry::SubBlock:
+      switch (Entry.ID) {
+      default:  // Skip unknown content.
+        if (Stream.SkipBlock())
+          return error("Invalid record");
+        break;
+      case bitc::THINLTO_SYMTAB_BLOCK_ID:
+        if (std::error_code EC = parseThinLTOSymtab())
+          return EC;
+        break;
+      case bitc::THINLTO_FUNCTION_SUMMARY_BLOCK_ID:
+        if (!ParseFuncSummaryData) {
+          if (Stream.SkipBlock())
+            return error("Invalid record");
+        }
+        else if (std::error_code EC = parseThinLTOSummary())
+          return EC;
+        break;
+      case bitc::THINLTO_MODULE_STRTAB_BLOCK_ID:
+        if (std::error_code EC = parseThinLTOModuleStringTable())
+          return EC;
+        break;
+      }
+      continue;
+
+    // TODO: Add ThinLTO version number record.
+    case BitstreamEntry::Record:
+      return error("Invalid record");
+    }
+  }
+  llvm_unreachable("Exit infinite loop");
+}
+
+std::error_code ThinLTOBitcodeReader::parseThinLTOSymtab() {
+  if (Stream.EnterSubBlock(bitc::THINLTO_SYMTAB_BLOCK_ID))
+    return error("Invalid record");
+
+  SmallVector<uint64_t, 64> Record;
+
+  while (1) {
+    BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
+
+    switch (Entry.Kind) {
+    case BitstreamEntry::SubBlock: // Handled for us already.
+    case BitstreamEntry::Error:
+      return error("Malformed block");
+    case BitstreamEntry::EndBlock:
+      return std::error_code();
+    case BitstreamEntry::Record:
+      // The interesting case.
+      break;
+    }
+
+    // TODO: Read a record.
+    Record.clear();
+    switch (Stream.readRecord(Entry.ID, Record)) {
+    default:  // Default behavior: ignore.
+      break;
+    }
+  }
+  llvm_unreachable("Exit infinite loop");
+}
+
+std::error_code ThinLTOBitcodeReader::parseThinLTOSummary() {
+  if (Stream.EnterSubBlock(bitc::THINLTO_FUNCTION_SUMMARY_BLOCK_ID))
+    return error("Invalid record");
+
+  SmallVector<uint64_t, 64> Record;
+
+  while (1) {
+    BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
+
+    switch (Entry.Kind) {
+    case BitstreamEntry::SubBlock: // Handled for us already.
+    case BitstreamEntry::Error:
+      return error("Malformed block");
+    case BitstreamEntry::EndBlock:
+      return std::error_code();
+    case BitstreamEntry::Record:
+      // The interesting case.
+      break;
+    }
+
+    // TODO: Read a record.
+    Record.clear();
+    switch (Stream.readRecord(Entry.ID, Record)) {
+    default:  // Default behavior: ignore.
+      break;
+    }
+  }
+  llvm_unreachable("Exit infinite loop");
+}
+
+std::error_code ThinLTOBitcodeReader::parseThinLTOModuleStringTable() {
+  if (Stream.EnterSubBlock(bitc::THINLTO_MODULE_STRTAB_BLOCK_ID))
+    return error("Invalid record");
+
+  SmallVector<uint64_t, 64> Record;
+
+  while (1) {
+    BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
+
+    switch (Entry.Kind) {
+    case BitstreamEntry::SubBlock: // Handled for us already.
+    case BitstreamEntry::Error:
+      return error("Malformed block");
+    case BitstreamEntry::EndBlock:
+      return std::error_code();
+    case BitstreamEntry::Record:
+      // The interesting case.
+      break;
+    }
+
+    // TODO: Read a record.
+    Record.clear();
+    switch (Stream.readRecord(Entry.ID, Record)) {
+    default:  // Default behavior: ignore.
+      break;
+    }
+  }
+  llvm_unreachable("Exit infinite loop");
+}
+
+std::error_code
+ThinLTOBitcodeReader::parseBitcodeInto(std::unique_ptr<DataStreamer> Streamer,
+                                       ThinLTOFunctionSummaryIndex *I) {
+  TheIndex = I;
+
+  if (std::error_code EC = initStream(std::move(Streamer)))
+    return EC;
+
+  // Sniff for the signature.
+  if (Stream.Read(8) != 'B' ||
+      Stream.Read(8) != 'C' ||
+      Stream.Read(4) != 0x0 ||
+      Stream.Read(4) != 0xC ||
+      Stream.Read(4) != 0xE ||
+      Stream.Read(4) != 0xD)
+    return error("Invalid bitcode signature");
+
+  // We expect a number of well-defined blocks, though we don't necessarily
+  // need to understand them all.
+  while (1) {
+    if (Stream.AtEndOfStream()) {
+      // We didn't really read a proper Module block.
+      return error("Malformed ThihLTO IR file");
+    }
+
+    BitstreamEntry Entry =
+      Stream.advance(BitstreamCursor::AF_DontAutoprocessAbbrevs);
+
+    if (Entry.Kind != BitstreamEntry::SubBlock)
+      return error("Malformed block");
+
+    // If we see a MODuLE_BLOCK then presumably we are expecting to read a full
+    // THINLTO_BLOCK from a bitcode-only file.
+    if (Entry.ID == bitc::MODULE_BLOCK_ID) {
+      assert (BufferType == bitc::THINLTO_BLOCK_ID);
+      return parseModule();
+    }
+
+    // If we see the summary block first, then presumably we are reading
+    // the function summary section from a native-object file.
+    else if (Entry.ID == bitc::THINLTO_FUNCTION_SUMMARY_BLOCK_ID) {
+      assert (BufferType == bitc::THINLTO_FUNCTION_SUMMARY_BLOCK_ID);
+      if (ParseFuncSummaryData)
+        return parseThinLTOSummary();
+    }
+
+    // If we see the module strtab block first, then presumably we are reading
+    // the module strtab section from a native-object file.
+    else if (Entry.ID == bitc::THINLTO_MODULE_STRTAB_BLOCK_ID) {
+      assert (BufferType == bitc::THINLTO_MODULE_STRTAB_BLOCK_ID);
+      return parseThinLTOModuleStringTable();
+    }
+
+    if (Stream.SkipBlock())
+      return error("Invalid record");
+  }
+}
+
+// Parse the function information at the given offset in the buffer into
+// the index.
+std::error_code
+ThinLTOBitcodeReader::parseFunction(std::unique_ptr<DataStreamer> Streamer,
+                                    ThinLTOFunctionSummaryIndex *I,
+                                    size_t FunctionOffset) {
+  TheIndex = I;
+
+  if (std::error_code EC = initStream(std::move(Streamer)))
+    return EC;
+
+  // Sniff for the signature.
+  if (Stream.Read(8) != 'B' ||
+      Stream.Read(8) != 'C' ||
+      Stream.Read(4) != 0x0 ||
+      Stream.Read(4) != 0xC ||
+      Stream.Read(4) != 0xE ||
+      Stream.Read(4) != 0xD)
+    return error("Invalid bitcode signature");
+
+  Stream.JumpToBit(FunctionOffset);
+
+  BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
+
+  switch (Entry.Kind) {
+    default:
+      return error("Malformed block");
+    case BitstreamEntry::Record:
+      // The expected case.
+      break;
+  }
+
+  // TODO: Read a record.
+  SmallVector<uint64_t, 64> Record;
+  switch (Stream.readRecord(Entry.ID, Record)) {
+    default:  // Error, expected to jump to a valid function summary record.
+      return error("Invalid record");
+  }
+
+  return std::error_code();
+}
+
+std::error_code
+ThinLTOBitcodeReader::initStream(std::unique_ptr<DataStreamer> Streamer) {
+  if (Streamer)
+    return initLazyStream(std::move(Streamer));
+  return initStreamFromBuffer();
+}
+
+std::error_code ThinLTOBitcodeReader::initStreamFromBuffer() {
+  const unsigned char *BufPtr = (const unsigned char*)Buffer->getBufferStart();
+  const unsigned char *BufEnd = BufPtr+Buffer->getBufferSize();
+
+  if (Buffer->getBufferSize() & 3)
+    return error("Invalid bitcode signature");
+
+  // If we have a wrapper header, parse it and ignore the non-bc file contents.
+  // The magic number is 0x0B17C0DE stored in little endian.
+  if (isBitcodeWrapper(BufPtr, BufEnd))
+    if (SkipBitcodeWrapperHeader(BufPtr, BufEnd, true))
+      return error("Invalid bitcode wrapper header");
+
+  StreamFile.reset(new BitstreamReader(BufPtr, BufEnd));
+  Stream.init(&*StreamFile);
+
+  return std::error_code();
+}
+
+std::error_code
+ThinLTOBitcodeReader::initLazyStream(std::unique_ptr<DataStreamer> Streamer) {
+  // Check and strip off the bitcode wrapper; BitstreamReader expects never to
+  // see it.
+  auto OwnedBytes =
+      llvm::make_unique<StreamingMemoryObject>(std::move(Streamer));
+  StreamingMemoryObject &Bytes = *OwnedBytes;
+  StreamFile = llvm::make_unique<BitstreamReader>(std::move(OwnedBytes));
+  Stream.init(&*StreamFile);
+
+  unsigned char buf[16];
+  if (Bytes.readBytes(buf, 16, 0) != 16)
+    return error("Invalid bitcode signature");
+
+  if (!isBitcode(buf, buf + 16))
+    return error("Invalid bitcode signature");
+
+  if (isBitcodeWrapper(buf, buf + 4)) {
+    const unsigned char *bitcodeStart = buf;
+    const unsigned char *bitcodeEnd = buf + 16;
+    SkipBitcodeWrapperHeader(bitcodeStart, bitcodeEnd, false);
+    Bytes.dropLeadingBytes(bitcodeStart - buf);
+    Bytes.setKnownObjectSize(bitcodeEnd - bitcodeStart);
+  }
+  return std::error_code();
+}
+
 namespace {
 class BitcodeErrorCategoryType : public std::error_category {
   const char *name() const LLVM_NOEXCEPT override {
     return "llvm.bitcode";
   }
   std::string message(int IE) const override {
     BitcodeError E = static_cast<BitcodeError>(IE);
     switch (E) {
llvm::getBitcodeTargetTriple(MemoryBufferRef Buffer, LLVMContext &Context,
   std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false);
   auto R = llvm::make_unique<BitcodeReader>(Buf.release(), Context,
                                             DiagnosticHandler);
   ErrorOr<std::string> Triple = R->parseTriple();
   if (Triple.getError())
     return "";
   return Triple.get();
 }
+
+// Parse the given function summary and module strings bitcode buffers,
+// returning the ThinLTO index constructed using the given ThinLTO
+// function map. This interface is used in the native object wrapped
+// case, where the function map is constructed from the object's symbol
+// table. If ParseFuncSummary is true, parse the entire function summary into
+// the index, otherwise the summary buffer is ignored and may be empty.
+ErrorOr<std::unique_ptr<ThinLTOFunctionSummaryIndex>>
+llvm::getThinLTOIndex(MemoryBufferRef SummaryBuffer,
+                      MemoryBufferRef ModStringsBuffer,
+                      std::unique_ptr<ThinLTOFunctionMap> FuncMap,
+                      LLVMContext &Context,
+                      DiagnosticHandlerFunction DiagnosticHandler,
+                      bool ParseFuncSummary) {
+  std::unique_ptr<MemoryBuffer> SummaryBuf =
+      MemoryBuffer::getMemBuffer(SummaryBuffer, false);
+  ThinLTOBitcodeReader *SummaryR =
+      new ThinLTOBitcodeReader(SummaryBuf.get(), Context, DiagnosticHandler,
+                               ParseFuncSummary, false,
+                               bitc::THINLTO_FUNCTION_SUMMARY_BLOCK_ID);
+  std::unique_ptr<MemoryBuffer> ModStringsBuf =
+      MemoryBuffer::getMemBuffer(ModStringsBuffer, false);
+  ThinLTOBitcodeReader *ModStringsR =
+      new ThinLTOBitcodeReader(ModStringsBuf.get(), Context, DiagnosticHandler,
+                               false, false,
+                               bitc::THINLTO_MODULE_STRTAB_BLOCK_ID);
+
+  std::unique_ptr<ThinLTOFunctionSummaryIndex> Index =
+      llvm::make_unique<ThinLTOFunctionSummaryIndex>();
+
+  Index->setFunctionMap(std::move(*FuncMap));
+
+  if (std::error_code EC = SummaryR->parseBitcodeInto(nullptr, Index.get())) {
+    SummaryR->releaseBuffer(); // Never take ownership on error.
+    return EC;
+  };
+
+  if (std::error_code EC = ModStringsR->parseBitcodeInto(nullptr,
+                                                         Index.get())) {
+    ModStringsR->releaseBuffer(); // Never take ownership on error.
+    return EC;
+  };
+
+  SummaryBuf.release(); // The ThinLTOBitcodeReader owns it now.
+  ModStringsBuf.release(); // The ThinLTOBitcodeReader owns it now.
+  return std::move(Index);
+}
+
+static ErrorOr<std::unique_ptr<ThinLTOFunctionSummaryIndex>>
+getThinLTOIndexImpl(std::unique_ptr<MemoryBuffer> &&Buffer,
+                    LLVMContext &Context,
+                    DiagnosticHandlerFunction DiagnosticHandler,
+                    bool ParseFuncSummary) {
+  ThinLTOBitcodeReader *R =
+      new ThinLTOBitcodeReader(Buffer.get(), Context, DiagnosticHandler,
+                               ParseFuncSummary);
+
+  std::unique_ptr<ThinLTOFunctionSummaryIndex> Index =
+      llvm::make_unique<ThinLTOFunctionSummaryIndex>();
+
+  auto cleanupOnError = [&](std::error_code EC) {
+    R->releaseBuffer(); // Never take ownership on error.
+    return EC;
+  };
+
+  if (std::error_code EC = R->parseBitcodeInto(nullptr, Index.get()))
+    return cleanupOnError(EC);
+
+  Buffer.release(); // The ThinLTOBitcodeReader owns it now.
+  return std::move(Index);
+}
+
+// Parse the specified bitcode buffer, returning the ThinLTO index.
+// If ParseFuncSummary is true, parse the entire function summary into
+// the index, otherwise skip the function summary section.
+ErrorOr<std::unique_ptr<ThinLTOFunctionSummaryIndex>>
+llvm::getThinLTOIndex(MemoryBufferRef Buffer, LLVMContext &Context,
+                          DiagnosticHandlerFunction DiagnosticHandler,
+                          bool ParseFuncSummary) {
+  std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false);
+  return getThinLTOIndexImpl(std::move(Buf), Context, DiagnosticHandler,
+                             ParseFuncSummary);
+}
+
+static bool hasThinLTOIndexImpl(std::unique_ptr<MemoryBuffer> &&Buffer,
+                                LLVMContext &Context,
+                                DiagnosticHandlerFunction DiagnosticHandler) {
+  ThinLTOBitcodeReader *R =
+      new ThinLTOBitcodeReader(Buffer.get(), Context, DiagnosticHandler,
+                               false, true);
+
+  auto cleanupOnError = [&](std::error_code EC) {
+    R->releaseBuffer(); // Never take ownership on error.
+    return false;
+  };
+
+  if (std::error_code EC = R->parseBitcodeInto(nullptr, nullptr))
+    return cleanupOnError(EC);
+
+  Buffer.release(); // The ThinLTOBitcodeReader owns it now.
+  return R->foundThinLTO();
+}
+
+// Check if the given bitcode buffer contains a ThinLTO block.
+bool llvm::hasThinLTOIndex(MemoryBufferRef Buffer, LLVMContext &Context,
+    DiagnosticHandlerFunction DiagnosticHandler) {
+  std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false);
+  return hasThinLTOIndexImpl(std::move(Buf), Context, DiagnosticHandler);
+}
+
+static std::error_code readThinLTOFunctionInfoImpl(
+    std::unique_ptr<MemoryBuffer> &&Buffer, LLVMContext &Context,
+    DiagnosticHandlerFunction DiagnosticHandler,
+    StringRef FunctionName,
+    std::unique_ptr<ThinLTOFunctionSummaryIndex> Index) {
+  ThinLTOBitcodeReader *R =
+      new ThinLTOBitcodeReader(Buffer.get(), Context, DiagnosticHandler);
+
+  auto cleanupOnError = [&](std::error_code EC) {
+    R->releaseBuffer(); // Never take ownership on error.
+    return EC;
+  };
+
+  // TODO: If we have a FunctionName, then we have the bitcode offset
+  // of it's summary within the Buffer saved in the ThinLTOFunctionSummary
+  // entry within the Index's ThinLTOFunctionMap entry for FunctionName.
+  // Access it and read the record directly. Also, we may have multiple
+  // entries for the function in the function map's list (e.g. COMDATS),
+  // so the below will need to be a loop.
+  size_t FunctionOffset = 0; /* TODO: fill this in. */
+
+  if (std::error_code EC = R->parseFunction(nullptr, Index.get(),
+                                            FunctionOffset))
+    return cleanupOnError(EC);
+
+  Buffer.release(); // The ThinLTOBitcodeReader owns it now.
+  return std::error_code();
+}
+
+// Parse the summary information for the given function name into
+// the given index. This is used when we already parsed the rest of
+// the index with getThinLTOIndex and ParseFuncSummary=false.
+// It handles both the bitcode-only and native-object wrapped bitcode
+// cases.
+std::error_code llvm::readThinLTOFunctionInfo(
+    MemoryBufferRef Buffer, LLVMContext &Context,
+    DiagnosticHandlerFunction DiagnosticHandler,
+    StringRef FunctionName,
+    std::unique_ptr<ThinLTOFunctionSummaryIndex> Index) {
+  std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false);
+  return readThinLTOFunctionInfoImpl(std::move(Buf), Context, DiagnosticHandler,
+                                     FunctionName, std::move(Index));
+}

lib/Bitcode/Writer/BitcodeWriter.cpp

 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/InlineAsm.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/IR/UseListOrder.h"
 #include "llvm/IR/ValueSymbolTable.h"
+#include "llvm/MC/MCStreamer.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cctype>
 #include <map>
 using namespace llvm;
// FIXME: This should only use space for first class types!
     if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) !=
         FUNCTION_INST_GEP_ABBREV)
       llvm_unreachable("Unexpected abbrev ordering!");
   }
 
   Stream.ExitBlock();
 }
 
+static void WriteThinLTOModStrings(const ThinLTOFunctionSummaryIndex *I,
+                                   BitstreamWriter &Stream) {
+  Stream.EnterSubblock(bitc::THINLTO_MODULE_STRTAB_BLOCK_ID, 3);
+  // TODO: Write records
+  Stream.ExitBlock();
+}
+
+static void WriteThinLTOSummary(const ThinLTOFunctionSummaryIndex *I,
+                                BitstreamWriter &Stream) {
+  Stream.EnterSubblock(bitc::THINLTO_FUNCTION_SUMMARY_BLOCK_ID, 3);
+  // TODO: Write records
+  Stream.ExitBlock();
+}
+
+static void WriteThinLTOSymtab(const ThinLTOFunctionSummaryIndex *I,
+                               BitstreamWriter &Stream) {
+  Stream.EnterSubblock(bitc::THINLTO_SYMTAB_BLOCK_ID, 3);
+  // TODO: Write records. We need to have built up a map from function
+  // name to ValueID saved on the Index before this.
+  Stream.ExitBlock();
+}
+
+static void WriteThinLTOBlock(const ThinLTOFunctionSummaryIndex *I,
+                              BitstreamWriter &Stream) {
+  Stream.EnterSubblock(bitc::THINLTO_BLOCK_ID, 3);
+
+  WriteThinLTOModStrings(I, Stream);
+  WriteThinLTOSummary(I, Stream);
+  WriteThinLTOSymtab(I, Stream);
+
+  Stream.ExitBlock();
+}
+
 /// WriteModule - Emit the specified module to the bitstream.
 static void WriteModule(const Module *M, BitstreamWriter &Stream,
                         bool ShouldPreserveUseListOrder) {
   Stream.EnterSubblock(bitc::MODULE_BLOCK_ID, 3);
 
   SmallVector<unsigned, 1> Vals;
   unsigned CurVersion = 1;
   Vals.push_back(CurVersion);
static void WriteModule(const Module *M, BitstreamWriter &Stream,
   if (VE.shouldPreserveUseListOrder())
     WriteUseListBlock(nullptr, VE, Stream);
 
   // Emit function bodies.
   for (Module::const_iterator F = M->begin(), E = M->end(); F != E; ++F)
     if (!F->isDeclaration())
       WriteFunction(*F, VE, Stream);
 
+#if 0
+  // TODO: Put this under the option for generating the per-module
+  // ThinLTO function index/summary in the compile step.
+  // Write the ThinLTO info (index will eventually be non-null).
+  WriteThinLTOBlock(nullptr, Stream);
+#endif
+
   Stream.ExitBlock();
 }
 
 /// EmitDarwinBCHeader - If generating a bc file on darwin, we have to emit a
 /// header and trailer to make it compatible with the system archiver.  To do
 /// this we emit the following header, and then emit a trailer that pads the
 /// file out to be a multiple of 16 bytes.
 ///
void llvm::WriteBitcodeToFile(const Module *M, raw_ostream &Out,
   }
 
   if (TT.isOSDarwin())
     EmitDarwinBCHeaderAndTrailer(Buffer, TT);
 
   // Write the generated bitstream to "Out".
   Out.write((char*)&Buffer.front(), Buffer.size());
 }
+
+// TODO: Write Module IR to .llvmbc section. Analagous to WriteBitcodeToFile.
+void llvm::WriteModuleToStreamer(const Module *M, MCStreamer &MCS) {
+}
+
+// Write the specified ThinLTO 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.
+void llvm::WriteThinLTOToFile(const ThinLTOFunctionSummaryIndex *Index,
+                              raw_ostream &Out) {
+  SmallVector<char, 0> Buffer;
+  Buffer.reserve(256*1024);
+
+  BitstreamWriter Stream(Buffer);
+
+  // Emit the bitcode header.
+  Stream.Emit((unsigned)'B', 8);
+  Stream.Emit((unsigned)'C', 8);
+  Stream.Emit(0x0, 4);
+  Stream.Emit(0xC, 4);
+  Stream.Emit(0xE, 4);
+  Stream.Emit(0xD, 4);
+
+  WriteThinLTOBlock(Index, Stream);
+
+  Out.write((char*)&Buffer.front(), Buffer.size());
+}
+
+void WriteThinLTOSummaryToStreamer(const ThinLTOFunctionSummaryIndex *Index,
+                                   MCStreamer &MCS) {
+  SmallVector<char, 0> Buffer;
+  Buffer.reserve(256*1024);
+
+  BitstreamWriter Stream(Buffer);
+
+  // Emit the bitcode header.
+  Stream.Emit((unsigned)'B', 8);
+  Stream.Emit((unsigned)'C', 8);
+  Stream.Emit(0x0, 4);
+  Stream.Emit(0xC, 4);
+  Stream.Emit(0xE, 4);
+  Stream.Emit(0xD, 4);
+
+  WriteThinLTOSummary(Index, Stream);
+
+  // Emit the generated bitstream to the MCStreamer.
+  StringRef Str(Buffer.data(), Buffer.size());
+  MCS.EmitBytes(Str);
+}
+
+void WriteThinLTOModStringsToStreamer(const ThinLTOFunctionSummaryIndex *Index,
+                                      MCStreamer &MCS) {
+  SmallVector<char, 0> Buffer;
+  Buffer.reserve(256*1024);
+
+  BitstreamWriter Stream(Buffer);
+
+  // Emit the bitcode header.
+  Stream.Emit((unsigned)'B', 8);
+  Stream.Emit((unsigned)'C', 8);
+  Stream.Emit(0x0, 4);
+  Stream.Emit(0xC, 4);
+  Stream.Emit(0xE, 4);
+  Stream.Emit(0xD, 4);
+
+  WriteThinLTOModStrings(Index, Stream);
+
+  // Emit the generated bitstream to the MCStreamer.
+  StringRef Str(Buffer.data(), Buffer.size());
+  MCS.EmitBytes(Str);
+}
+
+// Write the specified ThinLTO index to the given target specific
+// streamer, where it will be wrapped in native object sections.
+void llvm::WriteThinLTOToStreamer(const ThinLTOFunctionSummaryIndex *Index,
+                                  MCStreamer &MCS) {
+  // TODO: ensure symbol table is written to native-wrapped object, and
+  // that symbol table value is offset into ThinLTO function summary section.
+
+  WriteThinLTOModStringsToStreamer(Index, MCS);
+  WriteThinLTOSummaryToStreamer(Index, MCS);
+}

lib/Bitcode/Writer/LLVMBuild.txt

 ;   http://llvm.org/docs/LLVMBuild.html
 ;
 ;===------------------------------------------------------------------------===;
 
 [component_0]
 type = Library
 name = BitWriter
 parent = Bitcode
-required_libraries = Core Support
+required_libraries = Core MC Support

tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp

static const char *GetBlockName(unsigned BlockID,
   case bitc::PARAMATTR_GROUP_BLOCK_ID: return "PARAMATTR_GROUP_BLOCK_ID";
   case bitc::TYPE_BLOCK_ID_NEW:        return "TYPE_BLOCK_ID";
   case bitc::CONSTANTS_BLOCK_ID:       return "CONSTANTS_BLOCK";
   case bitc::FUNCTION_BLOCK_ID:        return "FUNCTION_BLOCK";
   case bitc::VALUE_SYMTAB_BLOCK_ID:    return "VALUE_SYMTAB";
   case bitc::METADATA_BLOCK_ID:        return "METADATA_BLOCK";
   case bitc::METADATA_ATTACHMENT_ID:   return "METADATA_ATTACHMENT_BLOCK";
   case bitc::USELIST_BLOCK_ID:         return "USELIST_BLOCK_ID";
+  case bitc::THINLTO_BLOCK_ID:         return "THINLTO_BLOCK";
+  case bitc::THINLTO_SYMTAB_BLOCK_ID:  return "THINLTO_SYMTAB_BLOCK";
+  case bitc::THINLTO_FUNCTION_SUMMARY_BLOCK_ID:
+                                       return "THINLTO_FUNCTION_SUMMARY_BLOCK";
+  case bitc::THINLTO_MODULE_STRTAB_BLOCK_ID:
+                                       return "THINLTO_MODULE_STRTAB_BLOCK";
   }
 }
 
 /// GetCodeName - Return a symbolic code name if known, otherwise return
 /// null.
 static const char *GetCodeName(unsigned CodeID, unsigned BlockID,
                                const BitstreamReader &StreamFile,
                                CurStreamTypeType CurStreamType) {