Add (unsupported experimental) feature allowing byte aligned bitcode.

include/llvm/Bitcode/NaCl/NaClBitstreamWriter.h

 //===- NaClBitstreamWriter.h - NaCl bitstream writer ------------*- C++ -*-===//
 //
 //                     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 BitstreamWriter class.  This class can be used to
 // write an arbitrary bitstream, regardless of its contents.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_BITCODE_NACL_NACLBITSTREAMWRITER_H
 #define LLVM_BITCODE_NACL_NACLBITSTREAMWRITER_H
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Bitcode/NaCl/NaClBitCodes.h"
+#include "llvm/Bitcode/NaCl/NaClBitcodeHeader.h"
 #include <vector>
 
 namespace llvm {
 
 class NaClBitstreamWriter {
   SmallVectorImpl<char> &Out;
 
   /// CurBit - Always between 0 and 31 inclusive, specifies the next bit to use.
   unsigned CurBit;
 
@@ skipping 23 matching lines @@
   std::vector<Block> BlockScope;
 
   /// BlockInfo - 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;
   };
   std::vector<BlockInfo> BlockInfoRecords;
 
+  // True if filler should be added to byte align records.
+  bool AlignBitcodeRecords = false;
+
   /// AbbrevValues - Wrapper class that allows the bitstream writer to
   /// prefix a code to the set of values, associated with a record to
   /// emit, without having to destructively change the contents of
   /// values.
   template<typename uintty>
   struct AbbrevValues {
     AbbrevValues(uintty Code, const SmallVectorImpl<uintty> &Values)
         : Code(Code), Values(Values) {}
 
     size_t size() const {
@@ skipping 56 matching lines @@
     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();
       BlockInfoRecords.pop_back();
     }
   }
 
+  void initFromHeader(const NaClBitcodeHeader &Header) {
+    AlignBitcodeRecords = Header.getAlignBitcodeRecords();
+  }
+
   /// \brief Retrieve the current position in the stream, in bits.
   uint64_t GetCurrentBitNo() const { return GetBufferOffset() * 8 + CurBit; }
 
   //===--------------------------------------------------------------------===//
   // Basic Primitives for emitting bits to the stream.
   //===--------------------------------------------------------------------===//
 
   void Emit(uint32_t Val, unsigned NumBits) {
     assert(NumBits && NumBits <= 32 && "Invalid value size!");
     assert((Val & ~(~0U >> (32-NumBits))) == 0 && "High bits set!");
@@ skipping 15 matching lines @@
 
   void Emit64(uint64_t Val, unsigned NumBits) {
     if (NumBits <= 32)
       Emit((uint32_t)Val, NumBits);
     else {
       Emit((uint32_t)Val, 32);
       Emit((uint32_t)(Val >> 32), NumBits-32);
     }
   }
 
+  void flushToByte() {
+    unsigned BitsToFlush = (32 - CurBit) % CHAR_BIT;
+    if (BitsToFlush)
+      Emit(0, BitsToFlush);
+  }
+
+  void flushToByteIfAligned() {
+    if (AlignBitcodeRecords)
+      flushToByte();
+  }
+
   void FlushToWord() {
     if (CurBit) {
       WriteWord(CurValue);
       CurBit = 0;
       CurValue = 0;
     }
   }
 
   void EmitVBR(uint32_t Val, unsigned NumBits) {
     assert(NumBits <= 32 && "Too many bits to emit!");
@@ skipping 224 matching lines @@
   void EmitRecord(unsigned Code, const SmallVectorImpl<uintty> &Vals,
                   unsigned Abbrev = 0) {
     if (!Abbrev) {
       // If we don't have an abbrev to use, emit this in its fully unabbreviated
       // form.
       EmitCode(naclbitc::UNABBREV_RECORD);
       EmitVBR(Code, 6);
       EmitVBR(static_cast<uint32_t>(Vals.size()), 6);
       for (unsigned i = 0, e = static_cast<unsigned>(Vals.size()); i != e; ++i)
         EmitVBR64(Vals[i], 6);
+      flushToByteIfAligned();
       return;
     }
 
     // combine code and values, and then emit.
     AbbrevValues<uintty> AbbrevVals(Code, Vals);
     EmitRecordWithAbbrevImpl(Abbrev, AbbrevVals);
+    flushToByteIfAligned();
   }
 
   //===--------------------------------------------------------------------===//
   // Abbrev Emission
   //===--------------------------------------------------------------------===//
 
 private:
   // Emit the abbreviation as a DEFINE_ABBREV record.
   void EncodeAbbrev(NaClBitCodeAbbrev *Abbv) {
     EmitCode(naclbitc::DEFINE_ABBREV);
     EmitVBR(Abbv->getNumOperandInfos(), 5);
     for (unsigned i = 0, e = static_cast<unsigned>(Abbv->getNumOperandInfos());
          i != e; ++i) {
       const NaClBitCodeAbbrevOp &Op = Abbv->getOperandInfo(i);
       bool IsLiteral = Op.isLiteral();
       Emit(IsLiteral, 1);
       if (IsLiteral) {
         EmitVBR64(Op.getValue(), 8);
       } else {
         Emit(Op.getEncoding(), 3);
         if (Op.hasValue())
           EmitVBR64(Op.getValue(), 5);
       }
     }
+    flushToByteIfAligned();
   }
 public:
 
   /// EmitAbbrev - This emits an abbreviation to the stream.  Note that this
   /// method takes ownership of the specified abbrev.
   unsigned EmitAbbrev(NaClBitCodeAbbrev *Abbv) {
     assert(Abbv->isValid() && "Can't emit invalid abbreviation!");
     // Emit the abbreviation as a record.
     EncodeAbbrev(Abbv);
     CurAbbrevs.push_back(Abbv);
@@ skipping 44 matching lines @@
     Info.Abbrevs.push_back(Abbv);
 
     return Info.Abbrevs.size()-1+naclbitc::FIRST_APPLICATION_ABBREV;
   }
 };
 
 
 } // End llvm namespace
 
 #endif