Add (unsupported experimental) feature allowing byte aligned bitcode.

lib/Bitcode/NaCl/Writer/NaClBitcodeWriter.cpp

 //===--- Bitcode/NaCl/Writer/NaClBitcodeWriter.cpp - Bitcode Writer -------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Bitcode writer implementation.
@@ skipping 22 matching lines @@
 #include "llvm/Support/raw_ostream.h"
 #include <cctype>
 #include <map>
 using namespace llvm;
 
 static cl::opt<unsigned>
 PNaClVersion("pnacl-version",
              cl::desc("Specify PNaCl bitcode version to write"),
              cl::init(2));
 
+static cl::opt<bool>
+AlignBitcodeRecords("align-bitcode-records",
+    cl::desc("Align bitcode records in PNaCl bitcode files (experimental)"),
+    cl::init(false));
+
 /// These are manifest constants used by the bitcode writer. They do
 /// not need to be kept in sync with the reader, but need to be
 /// consistent within this file.
 ///
 /// Note that for each block type GROUP, the last entry should be of
 /// the form:
 ///
 ///    GROUP_MAX_ABBREV = GROUP_LAST_ABBREV,
 ///
 /// where GROUP_LAST_ABBREV is the last defined abbreviation. See
@@ skipping 1114 matching lines @@
 // Max size for variable fields. Currently only used for writing them
 // out to files (the parsing works for arbitrary sizes).
 static const size_t kMaxVariableFieldSize = 256;
 
 void llvm::NaClWriteHeader(NaClBitstreamWriter &Stream,
                            bool AcceptSupportedOnly) {
   NaClBitcodeHeader Header;
   Header.push_back(
       new NaClBitcodeHeaderField(NaClBitcodeHeaderField::kPNaClVersion,
                                  PNaClVersion));
+  if (AlignBitcodeRecords)
+    Header.push_back(new NaClBitcodeHeaderField(
+        NaClBitcodeHeaderField::kAlignBitcodeRecords));
+
   Header.InstallFields();
   if (!(Header.IsSupported() ||
         (!AcceptSupportedOnly && Header.IsReadable()))) {
     report_fatal_error(Header.Unsupported());
   }
   NaClWriteHeader(Header, Stream);
 }
 
 // Write out the given Header to the bitstream.
 void llvm::NaClWriteHeader(const NaClBitcodeHeader &Header,
                            NaClBitstreamWriter &Stream) {
+  Stream.initFromHeader(Header);
+
   // Emit the file magic number;
   Stream.Emit((unsigned)'P', 8);
   Stream.Emit((unsigned)'E', 8);
   Stream.Emit((unsigned)'X', 8);
   Stream.Emit((unsigned)'E', 8);
 
   // Emit placeholder for number of bytes used to hold header fields.
   // This value is necessary so that the streamable reader can preallocate
   // a buffer to read the fields.
   Stream.Emit(0, naclbitc::BlockSizeWidth);
@@ skipping 34 matching lines @@
   // Emit the module into the buffer.
   {
     NaClBitstreamWriter Stream(Buffer);
     NaClWriteHeader(Stream, AcceptSupportedOnly);
     WriteModule(M, Stream);
   }
 
   // Write the generated bitstream to "Out".
   Out.write((char*)&Buffer.front(), Buffer.size());
 }