Add (unsupported experimental) feature allowing byte aligned bitcode.

lib/Bitcode/NaCl/Reader/NaClBitcodeHeader.cpp

 //===- NaClBitcodeHeader.cpp ----------------------------------------------===//
 //     PNaCl bitcode header reader.
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Bitcode/NaCl/NaClBitcodeHeader.h"
+
+#include "llvm/ADT/SmallSet.h"
 #include "llvm/Bitcode/NaCl/NaClReaderWriter.h"
 #include "llvm/Bitcode/ReaderWriter.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/StreamingMemoryObject.h"
 
-#include <limits>
 #include <cstring>
 #include <iomanip>
+#include <limits>
 
 using namespace llvm;
 
+namespace {
+
+// The name for each ID tag.
+static const char *TagName[] = {
+  "Invalid",              // kInvalid
+  "PNaCl Version",        // kPNaClVersion
+  "Align bitcode records" // kAlignBitcodeRecords
+};
+
+// The name for each field type.
+static const char *FieldTypeName[] = {
+  "uint8[]", // kBufferType
+  "uint32",  // kUInt32Type
+  "flag",    // kFlagType
+  "unknown"  // kUnknownType
+};
+
+// The type associated with each ID tag.
+static const NaClBitcodeHeaderField::FieldType ExpectedType[] = {
+  NaClBitcodeHeaderField::kUnknownType, // kInvalid
+  NaClBitcodeHeaderField::kUInt32Type,  // kPNaClVersion
+  NaClBitcodeHeaderField::kFlagType     // kAlignBitcodeRecords
+};
+
+} // end of anonymous namespace
+
+const char *NaClBitcodeHeaderField::IDName(Tag ID) {
+  return ID > kTag_MAX ? "???" : TagName[ID];
+}
+
+const char *NaClBitcodeHeaderField::TypeName(FieldType FType) {
+  return FType > kFieldType_MAX ? "???" : FieldTypeName[FType];
+}
+
 NaClBitcodeHeaderField::NaClBitcodeHeaderField()
-    : ID(kInvalid), FType(kBufferType), Len(0), Data(0) {}
+  : ID(kInvalid), FType(kBufferType), Len(0), Data(0) {}
+
+NaClBitcodeHeaderField::NaClBitcodeHeaderField(Tag MyID)
+  : ID(MyID), FType(kFlagType), Len(0), Data(0) {
+  assert(MyID <= kTag_MAX);
+}
 
 NaClBitcodeHeaderField::NaClBitcodeHeaderField(Tag MyID, uint32_t MyValue)
     : ID(MyID), FType(kUInt32Type), Len(4), Data(new uint8_t[4]) {
+  assert(MyID <= kTag_MAX);
   Data[0] = static_cast<uint8_t>(MyValue & 0xFF);
   Data[1] = static_cast<uint8_t>((MyValue >> 8) & 0xFF);
   Data[2] = static_cast<uint8_t>((MyValue >> 16) & 0xFF);
   Data[3] = static_cast<uint8_t>((MyValue >> 24) & 0xFF);
 }
 
 uint32_t NaClBitcodeHeaderField::GetUInt32Value() const {
   assert(FType == kUInt32Type && "Header field must be uint32");
   return static_cast<uint32_t>(Data[0]) |
          (static_cast<uint32_t>(Data[1]) << 8) |
          (static_cast<uint32_t>(Data[2]) << 16) |
          (static_cast<uint32_t>(Data[2]) << 24);
 }
 
 NaClBitcodeHeaderField::NaClBitcodeHeaderField(Tag MyID, size_t MyLen,
                                                uint8_t *MyData)
     : ID(MyID), FType(kBufferType), Len(MyLen), Data(new uint8_t[MyLen]) {
+  assert(MyID <= kTag_MAX);
   for (size_t i = 0; i < MyLen; ++i) {
     Data[i] = MyData[i];
   }
 }
 
 bool NaClBitcodeHeaderField::Write(uint8_t *Buf, size_t BufLen) const {
   size_t FieldsLen = kTagLenSize + Len;
   size_t PadLen = (WordSize - (FieldsLen & (WordSize-1))) & (WordSize-1);
   // Ensure buffer is large enough and that length can be represented
   // in 32 bits
@@ skipping 30 matching lines @@
   }
   Len = Length;
   DecodeTypedID(IdField, ID, FType);
   memcpy(Data, Buf + kTagLenSize, Len);
   return true;
 }
 
 std::string NaClBitcodeHeaderField::Contents() const {
   std::string buffer;
   raw_string_ostream ss(buffer);
-  switch (ID) {
-  case kPNaClVersion:
-    ss << "PNaCl Version";
+  ss << IDName() << ": ";
+  switch (FType) {
+  case kFlagType:
+    ss << "true";
     break;
-  case kInvalid:
-    ss << "Invalid";
-    break;
-  }
-  ss << ": ";
-  switch (FType) {
   case kUInt32Type:
     ss << GetUInt32Value();
     break;
   case kBufferType:
     ss << "[";
     for (size_t i = 0; i < Len; ++i) {
       if (i)
         ss << " ";
       ss << format("%02x", Data[i]);
     }
     ss << "]";
     break;
+  case kUnknownType:
+    ss << "unknown value";
+    break;
   }
   return ss.str();
 }
 
 NaClBitcodeHeader::NaClBitcodeHeader()
     : HeaderSize(0), UnsupportedMessage(), IsSupportedFlag(false),
       IsReadableFlag(false), PNaClVersion(0) {}
 
 NaClBitcodeHeader::~NaClBitcodeHeader() {
   for (std::vector<NaClBitcodeHeaderField *>::const_iterator
@@ skipping 39 matching lines @@
     NaClBitcodeHeaderField *Field = new NaClBitcodeHeaderField();
     Fields.push_back(Field);
     if (!Field->Read(BufPtr, BufEnd - BufPtr))
       return UnsupportedError("Bitcode read failure");
     size_t FieldSize = Field->GetTotalSize();
     BufPtr += FieldSize;
   }
   return false;
 }
 
-bool NaClBitcodeHeader::Read(const unsigned char *&BufPtr,
-                             const unsigned char *&BufEnd) {
+bool NaClBitcodeHeader::Read(const unsigned char *BufPtr,
+                             const unsigned char *BufEnd) {
   unsigned NumFields;
   unsigned NumBytes;
   if (ReadPrefix(BufPtr, BufEnd, NumFields, NumBytes))
     return true; // ReadPrefix sets UnsupportedMessage
   BufPtr += 2 * WordSize;
 
   if (ReadFields(BufPtr, BufEnd, NumFields, NumBytes))
     return true; // ReadFields sets UnsupportedMessage
   BufPtr += NumBytes;
   InstallFields();
@@ skipping 47 matching lines @@
   if (NaClBitcodeHeaderField *Version =
           Header->GetTaggedField(NaClBitcodeHeaderField::kPNaClVersion)) {
     if (Version->GetType() == NaClBitcodeHeaderField::kUInt32Type) {
       return Version;
     }
   }
   return 0;
 }
 
 void NaClBitcodeHeader::InstallFields() {
-  // Assume supported until contradicted.
-  bool UpdatedUnsupportedMessage = false;
   IsSupportedFlag = true;
   IsReadableFlag = true;
-  UnsupportedMessage = "Supported";
+  AlignBitcodeRecords = false;
   PNaClVersion = 0;
-  if (NaClBitcodeHeaderField *Version = GetPNaClVersionPtr(this)) {
-    PNaClVersion = Version->GetUInt32Value();
-  }
-  if (PNaClVersion != 2) {
+  UnsupportedMessage.clear();
+  SmallSet<unsigned, NaClBitcodeHeaderField::kTag_MAX> FieldIDs;
+
+  auto ReportProblem = [&](bool IsReadable=false) {
+    UnsupportedMessage.append("\n");
     IsSupportedFlag = false;
-    IsReadableFlag = false;
-    UpdatedUnsupportedMessage = true;
-    UnsupportedMessage.clear();
-    raw_string_ostream UnsupportedStream(UnsupportedMessage);
-    UnsupportedStream << "Unsupported PNaCl bitcode version: "
-                      << PNaClVersion << "\n";
-    UnsupportedStream.flush();
-  }
-  if (Fields.size() != 1) {
-    IsSupportedFlag = false;
-    IsReadableFlag = false;
-    if (!UpdatedUnsupportedMessage)
-      UnsupportedMessage = "Unknown header field(s) found";
+    IsReadableFlag = IsReadableFlag && IsReadable;
+  };
+
+  auto ReportProblemWithContents = [&](NaClBitcodeHeaderField *Field,
+                                       bool IsReadable=false) {
+    UnsupportedMessage.append(": ");
+    UnsupportedMessage.append(Field->Contents());
+    ReportProblem(IsReadable);
+  };
+
+  for (size_t i = 0, e = NumberFields(); i < e; ++i) {
+    // Start by checking expected properties for any field
+    NaClBitcodeHeaderField *Field = GetField(i);
+    if (!FieldIDs.insert(Field->GetID()).second) {
+      UnsupportedMessage.append("Specified multiple times: ");
+      UnsupportedMessage.append(Field->IDName());
+      ReportProblem();
+      continue;
+    }
+    NaClBitcodeHeaderField::FieldType ExpectedTy = ExpectedType[Field->GetID()];
+    if (Field->GetType() != ExpectedTy) {
+      UnsupportedMessage.append("Expects type ");
+      UnsupportedMessage.append(NaClBitcodeHeaderField::TypeName(ExpectedTy));
+      ReportProblemWithContents(Field);
+      continue;
+    }
+    if (Field->GetType() == NaClBitcodeHeaderField::kUnknownType) {
+      UnsupportedMessage.append("Unknown value");
+      ReportProblemWithContents(Field);
+      continue;
+    }
+
+    // Check specific ID values and install.
+    switch (Field->GetID()) {
+    case NaClBitcodeHeaderField::kInvalid:
+      UnsupportedMessage.append("Unsupported");
+      ReportProblemWithContents(Field);
+      continue;
+    case NaClBitcodeHeaderField::kPNaClVersion:
+      PNaClVersion = Field->GetUInt32Value();
+      if (PNaClVersion != 2) {
+        UnsupportedMessage.append("Unsupported");
+        ReportProblemWithContents(Field);
+        continue;
+      }
+      break;
+    case NaClBitcodeHeaderField::kAlignBitcodeRecords:
+      AlignBitcodeRecords = true;
+      UnsupportedMessage.append("Unsupported");
+      ReportProblemWithContents(Field, true);
+      continue;
+    }
   }
 }