Add (unsupported experimental) feature allowing byte aligned bitcode.

include/llvm/Bitcode/NaCl/NaClBitstreamReader.h

 //===- NaClBitstreamReader.h -----------------------------------*- C++ -*-===//
 //     Low-level bitstream reader interface
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This header defines the BitstreamReader class.  This class can be used to
 // read an arbitrary bitstream, regardless of its contents.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_BITCODE_NACL_NACLBITSTREAMREADER_H
 #define LLVM_BITCODE_NACL_NACLBITSTREAMREADER_H
 
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/Bitcode/NaCl/NaClBitcodeHeader.h"
 #include "llvm/Bitcode/NaCl/NaClLLVMBitCodes.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/StreamingMemoryObject.h"
 #include <climits>
 #include <vector>
 
 namespace llvm {
 
 class Deserializer;
 
@@ skipping 24 matching lines @@
 /// the NaClBitstreamCursor class.
 class NaClBitstreamReader {
 public:
   /// This contains information emitted to BLOCKINFO_BLOCK blocks. These
   /// describe abbreviations that all blocks of the specified ID inherit.
   struct BlockInfo {
     unsigned BlockID;
     std::vector<NaClBitCodeAbbrev*> Abbrevs;
   };
 private:
+  friend class NaClBitstreamCursor;
+
   std::unique_ptr<MemoryObject> BitcodeBytes;
 
   std::vector<BlockInfo> BlockInfoRecords;
 
   /// \brief Holds the offset of the first byte after the header.
   size_t InitialAddress;
 
+  // True if filler should be added to byte align records.
+  bool AlignBitcodeRecords = false;
+
   NaClBitstreamReader(const NaClBitstreamReader&) LLVM_DELETED_FUNCTION;
   void operator=(const NaClBitstreamReader&) LLVM_DELETED_FUNCTION;
-public:
-  NaClBitstreamReader() : InitialAddress(0) {}
 
-  NaClBitstreamReader(const unsigned char *Start, const unsigned char *End,
-                      size_t MyInitialAddress=0) {
-    InitialAddress = MyInitialAddress;
-    init(Start, End);
+  void initFromHeader(NaClBitcodeHeader &Header) {
+    InitialAddress = Header.getHeaderSize();
+    AlignBitcodeRecords = Header.getAlignBitcodeRecords();
   }
 
-  NaClBitstreamReader(MemoryObject *Bytes, size_t MyInitialAddress=0)
-      : InitialAddress(MyInitialAddress) {
-    BitcodeBytes.reset(Bytes);
+public:
+  /// Read stream from sequence of bytes [Start .. End) after parsing
+  /// the given bitcode header.
+  NaClBitstreamReader(const unsigned char *Start, const unsigned char *End,
+                      NaClBitcodeHeader &Header)
+      : BitcodeBytes(getNonStreamedMemoryObject(Start, End)) {
+    initFromHeader(Header);
   }
 
-  void init(const unsigned char *Start, const unsigned char *End) {
-    assert(((End-Start) & 3) == 0 &&"Bitcode stream not a multiple of 4 bytes");
-    BitcodeBytes.reset(getNonStreamedMemoryObject(Start, End));
+  /// Read stream from Bytes, after parsing the given bitcode header.
+  NaClBitstreamReader(MemoryObject *Bytes, NaClBitcodeHeader &Header)
+      : BitcodeBytes(Bytes) {
+    initFromHeader(Header);
   }
 
+  /// Read stream from bytes, starting at the given initial address.
+  /// Provides simple API for unit testing.
+  NaClBitstreamReader(MemoryObject *Bytes, size_t InitialAddress)
+      : BitcodeBytes(Bytes), InitialAddress(InitialAddress) {
+  }
+
+  // Returns the memory object that is being read.
   MemoryObject &getBitcodeBytes() { return *BitcodeBytes; }
 
   ~NaClBitstreamReader() {
     // Free the BlockInfoRecords.
     while (!BlockInfoRecords.empty()) {
       BlockInfo &Info = BlockInfoRecords.back();
       // Free blockinfo abbrev info.
       for (unsigned i = 0, e = static_cast<unsigned>(Info.Abbrevs.size());
            i != e; ++i)
         Info.Abbrevs[i]->dropRef();
@@ skipping 407 matching lines @@
 
       if ((Piece & (1U << (NumBits-1))) == 0)
         return Result;
 
       NextBit += NumBits-1;
       Piece = Read(NumBits);
     }
   }
 
 private:
+  void SkipToByteBoundary() {
+    unsigned BitsToSkip = BitsInCurWord % CHAR_BIT;
+    if (BitsToSkip) {
+      CurWord >>= BitsToSkip;
+      BitsInCurWord -= BitsToSkip;
+    }
+  }
+
+  void SkipToByteBoundaryIfAligned() {
+    if (BitStream->AlignBitcodeRecords)
+      SkipToByteBoundary();
+  }
+
   void SkipToFourByteBoundary() {
     // If word_t is 64-bits and if we've read less than 32 bits, just dump
     // the bits we have up to the next 32-bit boundary.
     if (sizeof(word_t) > 4 &&
         BitsInCurWord >= 32) {
       CurWord >>= BitsInCurWord-32;
       BitsInCurWord = 32;
       return;
     }
 
@@ skipping 122 matching lines @@
   // Skips over an abbreviation record. Duplicates code of ReadAbbrevRecord,
   // except that no abbreviation is built.
   void SkipAbbrevRecord();
   
   bool ReadBlockInfoBlock(NaClAbbrevListener *Listener);
 };
 
 } // End llvm namespace
 
 #endif