[llvm-bcanalyzer] Dump bitcode wrapper header

[ahatanak]

Summary

This patch enables llvm-bcanalyzer to print the bitcode wrapper header if the file has one, which is needed to test the changes I made in r258627 (bitcode-wrapper-header-armv7m.ll is the test case for r258627).

Relevant discussion thread is here:
http://lists.llvm.org/pipermail/llvm-commits/Week-of-Mon-20160125/327698.html

[• rafael]

LGTM.

llvm/trunk/include/llvm/Bitcode/ReaderWriter.h

 namespace llvm {
   class BitstreamWriter;
   class DataStreamer;
   class LLVMContext;
   class Module;
   class ModulePass;
   class raw_ostream;
 
+  /// Offsets of the 32-bit fields of bitcode wrapper header.
+  static const unsigned BWH_MagicField = 0*4;
+  static const unsigned BWH_VersionField = 1*4;
+  static const unsigned BWH_OffsetField = 2*4;
+  static const unsigned BWH_SizeField = 3*4;
+  static const unsigned BWH_CPUTypeField = 4*4;
+  static const unsigned BWH_HeaderSize = 5*4;
+
   /// 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 successful, this moves Buffer. On
   /// error, this *does not* move Buffer.
   ErrorOr<std::unique_ptr<Module>>
   getLazyBitcodeModule(std::unique_ptr<MemoryBuffer> &&Buffer,
                        LLVMContext &Context,
                        bool ShouldLazyLoadMetadata = false);
namespace llvm {
   /// This function is called when we find a file with a matching magic number.
   /// In this case, skip down to the subsection of the file that is actually a
   /// BC file.
   /// If 'VerifyBufferSize' is true, check that the buffer is large enough to
   /// contain the whole bitcode file.
   inline bool SkipBitcodeWrapperHeader(const unsigned char *&BufPtr,
                                        const unsigned char *&BufEnd,
                                        bool VerifyBufferSize) {
-    enum {
-      KnownHeaderSize = 4*4,  // Size of header we read.
-      OffsetField = 2*4,      // Offset in bytes to Offset field.
-      SizeField = 3*4         // Offset in bytes to Size field.
-    };
-
-    // Must contain the header!
-    if (BufEnd-BufPtr < KnownHeaderSize) return true;
+    // Must contain the offset and size field!
+    if (BufEnd - BufPtr < BWH_SizeField + 4)
+      return true;
 
-    unsigned Offset = support::endian::read32le(&BufPtr[OffsetField]);
-    unsigned Size = support::endian::read32le(&BufPtr[SizeField]);
+    unsigned Offset = support::endian::read32le(&BufPtr[BWH_OffsetField]);
+    unsigned Size = support::endian::read32le(&BufPtr[BWH_SizeField]);
 
     // Verify that Offset+Size fits in the file.
     if (VerifyBufferSize && Offset+Size > unsigned(BufEnd-BufPtr))
       return true;
     BufPtr += Offset;
     BufEnd = BufPtr+Size;
     return false;
   }

llvm/trunk/lib/Bitcode/Writer/BitcodeWriter.cpp

 /// struct bc_header {
 ///   uint32_t Magic;         // 0x0B17C0DE
 ///   uint32_t Version;       // Version, currently always 0.
 ///   uint32_t BitcodeOffset; // Offset to traditional bitcode file.
 ///   uint32_t BitcodeSize;   // Size of traditional bitcode file.
 ///   uint32_t CPUType;       // CPU specifier.
 ///   ... potentially more later ...
 /// };
-enum {
-  DarwinBCSizeFieldOffset = 3*4, // Offset to bitcode_size.
-  DarwinBCHeaderSize = 5*4
-};
 
 static void WriteInt32ToBuffer(uint32_t Value, SmallVectorImpl<char> &Buffer,
                                uint32_t &Position) {
   support::endian::write32le(&Buffer[Position], Value);
   Position += 4;
 }
 
 static void EmitDarwinBCHeaderAndTrailer(SmallVectorImpl<char> &Buffer,
static void EmitDarwinBCHeaderAndTrailer(SmallVectorImpl<char> &Buffer,
   else if (Arch == Triple::ppc)
     CPUType = DARWIN_CPU_TYPE_POWERPC;
   else if (Arch == Triple::ppc64)
     CPUType = DARWIN_CPU_TYPE_POWERPC | DARWIN_CPU_ARCH_ABI64;
   else if (Arch == Triple::arm || Arch == Triple::thumb)
     CPUType = DARWIN_CPU_TYPE_ARM;
 
   // Traditional Bitcode starts after header.
-  assert(Buffer.size() >= DarwinBCHeaderSize &&
+  assert(Buffer.size() >= BWH_HeaderSize &&
          "Expected header size to be reserved");
-  unsigned BCOffset = DarwinBCHeaderSize;
-  unsigned BCSize = Buffer.size()-DarwinBCHeaderSize;
+  unsigned BCOffset = BWH_HeaderSize;
+  unsigned BCSize = Buffer.size() - BWH_HeaderSize;
 
   // Write the magic and version.
   unsigned Position = 0;
   WriteInt32ToBuffer(0x0B17C0DE , Buffer, Position);
   WriteInt32ToBuffer(0          , Buffer, Position); // Version.
   WriteInt32ToBuffer(BCOffset   , Buffer, Position);
   WriteInt32ToBuffer(BCSize     , Buffer, Position);
   WriteInt32ToBuffer(CPUType    , Buffer, Position);
void llvm::WriteBitcodeToFile(const Module *M, raw_ostream &Out,
                               bool EmitFunctionSummary) {
   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(), DarwinBCHeaderSize, 0);
+    Buffer.insert(Buffer.begin(), BWH_HeaderSize, 0);
 
   // 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.

llvm/trunk/test/Bitcode/bitcode-wrapper-header-armv7m.ll

+; RUN: llvm-as < %s | llvm-bcanalyzer -dump | FileCheck %s
+
+target triple = "thumbv7m-apple-unknown-macho"
+
+; CHECK: <BITCODE_WRAPPER_HEADER Magic=0x0b17c0de Version=0x{{[0-9a-f]+}} Offset=0x00000014 Size=0x{{[0-9a-f]+}} CPUType=0x0000000c/>

llvm/trunk/test/Bitcode/bitcode-wrapper-header-x86_64.ll

+; RUN: llvm-as < %s | llvm-bcanalyzer -dump | FileCheck %s
+
+target triple = "x86_64-apple-macosx10.11.0"
+
+; CHECK: <BITCODE_WRAPPER_HEADER Magic=0x0b17c0de Version=0x{{[0-9a-f]+}} Offset=0x00000014 Size=0x{{[0-9a-f]+}} CPUType=0x01000007/>

llvm/trunk/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp

static bool openBitcodeFile(StringRef Path,
   if (MemBuf->getBufferSize() & 3)
     return Error("Bitcode stream should be a multiple of 4 bytes in length");
 
   const unsigned char *BufPtr = (const unsigned char *)MemBuf->getBufferStart();
   const unsigned char *EndBufPtr = BufPtr + MemBuf->getBufferSize();
 
   // 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, EndBufPtr))
+  if (isBitcodeWrapper(BufPtr, EndBufPtr)) {
+    if (EndBufPtr - BufPtr < BWH_HeaderSize)
+      return Error("Invalid bitcode wrapper header");
+
+    if (Dump) {
+      unsigned Magic = support::endian::read32le(&BufPtr[BWH_MagicField]);
+      unsigned Version = support::endian::read32le(&BufPtr[BWH_VersionField]);
+      unsigned Offset = support::endian::read32le(&BufPtr[BWH_OffsetField]);
+      unsigned Size = support::endian::read32le(&BufPtr[BWH_SizeField]);
+      unsigned CPUType = support::endian::read32le(&BufPtr[BWH_CPUTypeField]);
+
+      outs() << "<BITCODE_WRAPPER_HEADER"
+             << " Magic=" << format_hex(Magic, 10)
+             << " Version=" << format_hex(Version, 10)
+             << " Offset=" << format_hex(Offset, 10)
+             << " Size=" << format_hex(Size, 10)
+             << " CPUType=" << format_hex(CPUType, 10) << "/>\n";
+    }
+
     if (SkipBitcodeWrapperHeader(BufPtr, EndBufPtr, true))
       return Error("Invalid bitcode wrapper header");
+  }
 
   StreamFile = BitstreamReader(BufPtr, EndBufPtr);
   Stream = BitstreamCursor(StreamFile);
   StreamFile.CollectBlockInfoNames();
 
   // Read the stream signature.
   char Signature[6];
   Signature[0] = Stream.Read(8);