Add (unsupported experimental) feature allowing byte aligned bitcode.

lib/Bitcode/NaCl/Reader/NaClBitstreamReader.cpp

 //===- NaClBitstreamReader.cpp --------------------------------------------===//
 //     NaClBitstreamReader implementation
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ skipping 125 matching lines @@
 
 /// skipRecord - Read the current record and discard it.
 void NaClBitstreamCursor::skipRecord(unsigned AbbrevID) {
   // Skip unabbreviated records by reading past their entries.
   if (AbbrevID == naclbitc::UNABBREV_RECORD) {
     unsigned Code = ReadVBR(6);
     (void)Code;
     unsigned NumElts = ReadVBR(6);
     for (unsigned i = 0; i != NumElts; ++i)
       (void)ReadVBR64(6);
+    SkipToByteBoundaryIfAligned();
     return;
   }
 
   const NaClBitCodeAbbrev *Abbv = getAbbrev(AbbrevID);
 
   for (unsigned i = 0, e = Abbv->getNumOperandInfos(); i != e; ++i) {
     const NaClBitCodeAbbrevOp &Op = Abbv->getOperandInfo(i);
     switch (Op.getEncoding()) {
     default:
       skipAbbreviatedField(Op);
       break;
     case NaClBitCodeAbbrevOp::Literal:
       break;
     case NaClBitCodeAbbrevOp::Array: {
       // Array case.  Read the number of elements as a vbr6.
       unsigned NumElts = ReadVBR(6);
 
       // Get the element encoding.
       const NaClBitCodeAbbrevOp &EltEnc = Abbv->getOperandInfo(++i);
 
       // Read all the elements.
       for (; NumElts; --NumElts)
         skipAbbreviatedField(EltEnc);
       break;
     }
     }
   }
+  SkipToByteBoundaryIfAligned();
 }
 
 bool NaClBitstreamCursor::readRecordAbbrevField(
     const NaClBitCodeAbbrevOp &Op, uint64_t &Value) {
   switch (Op.getEncoding()) {
   case NaClBitCodeAbbrevOp::Literal:
     Value = Op.getValue();
     break;
   case NaClBitCodeAbbrevOp::Array:
     // Returns number of elements in the array.
@@ skipping 40 matching lines @@
   }
 }
 
 unsigned NaClBitstreamCursor::readRecord(unsigned AbbrevID,
                                          SmallVectorImpl<uint64_t> &Vals) {
   if (AbbrevID == naclbitc::UNABBREV_RECORD) {
     unsigned Code = ReadVBR(6);
     unsigned NumElts = ReadVBR(6);
     for (unsigned i = 0; i != NumElts; ++i)
       Vals.push_back(ReadVBR64(6));
+    SkipToByteBoundaryIfAligned();
     return Code;
   }
 
   // Read code.
   const NaClBitCodeAbbrev *Abbv = getAbbrev(AbbrevID);
   uint64_t Value;
   unsigned Code;
   if (readRecordAbbrevField(Abbv->getOperandInfo(0), Value)) {
     // Array found, use to read all elements.
     if (Value == 0)
       ErrHandler->Fatal("No code found for record!");
     const NaClBitCodeAbbrevOp &Op = Abbv->getOperandInfo(1);
     Code = readArrayAbbreviatedField(Op);
     readArrayAbbrev(Op, Value - 1, Vals);
+    SkipToByteBoundaryIfAligned();
     return Code;
   }
   Code = Value;
 
   // Read arguments.
   unsigned NumOperands = Abbv->getNumOperandInfos();
   for (unsigned i = 1; i != NumOperands; ++i) {
     if (readRecordAbbrevField(Abbv->getOperandInfo(i), Value)) {
       ++i;
       readArrayAbbrev(Abbv->getOperandInfo(i), Value, Vals);
+      SkipToByteBoundaryIfAligned();
       return Code;
     }
     Vals.push_back(Value);
   }
+  SkipToByteBoundaryIfAligned();
   return Code;
 }
 
 
 NaClBitCodeAbbrevOp::Encoding NaClBitstreamCursor::
 getEncoding(uint64_t Value) {
   if (!NaClBitCodeAbbrevOp::isValidEncoding(Value)) {
     std::string Buffer;
     raw_string_ostream StrBuf(Buffer);
     StrBuf << "Invalid abbreviation encoding specified in bitcode file: "
@@ skipping 45 matching lines @@
       if (!NaClBitCodeAbbrevOp::isValid(E)) {
         std::string Buffer;
         raw_string_ostream StrBuf(Buffer);
         StrBuf << "Invalid abbreviation encoding ("
                << NaClBitCodeAbbrevOp::getEncodingName(E) << ")";
         report_fatal_error(StrBuf.str());
       }
       Abbv->Add(NaClBitCodeAbbrevOp(E));
     }
   }
+  SkipToByteBoundaryIfAligned();
   if (!Abbv->isValid())
     report_fatal_error("Invalid abbreviation specified in bitcode file");
   CurAbbrevs.push_back(Abbv);
   if (Listener) {
     Listener->ProcessAbbreviation(Abbv, IsLocal);
     // Reset record information of the listener.
     Listener->Values.clear();
     Listener->StartBit = GetCurrentBitNo();
   }
 }
 
 void NaClBitstreamCursor::SkipAbbrevRecord() {
   unsigned NumOpInfo = ReadVBR(5);
   for (unsigned i = 0; i != NumOpInfo; ++i) {
     bool IsLiteral = Read(1) ? true : false;
     if (IsLiteral) {
       ReadVBR64(8);
       continue;
     }
     NaClBitCodeAbbrevOp::Encoding E = getEncoding(Read(3));
     if (NaClBitCodeAbbrevOp::hasValue(E)) {
       ReadVBR64(5);
     }
   }
+  SkipToByteBoundaryIfAligned();
 }
 
 bool NaClBitstreamCursor::ReadBlockInfoBlock(NaClAbbrevListener *Listener) {
   // If this is the second stream to get to the block info block, skip it.
   if (BitStream->hasBlockInfoRecords())
     return SkipBlock();
 
   unsigned NumWords;
   if (EnterSubBlock(naclbitc::BLOCKINFO_BLOCK_ID, &NumWords)) return true;
 
@@ skipping 42 matching lines @@
         if (Record.size() < 1) return true;
         CurBlockInfo = &BitStream->getOrCreateBlockInfo((unsigned)Record[0]);
         if (Listener) {
           Listener->Values = Record;
           Listener->SetBID();
         }
         break;
     }
   }
 }