Add (unsupported experimental) feature allowing byte aligned bitcode.

include/llvm/Bitcode/NaCl/NaClBitcodeHeader.h

 //===-- llvm/Bitcode/NaCl/NaClBitcodeHeader.h - ----------------*- C++ -*-===//
 //      NaCl Bitcode header reader.
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
@@ skipping 20 matching lines @@
 // The serialized format has 2 fixed subfields (ID:type and data length) and the
 // variable-length data subfield
 class NaClBitcodeHeaderField {
   NaClBitcodeHeaderField(const NaClBitcodeHeaderField &) LLVM_DELETED_FUNCTION;
   void operator=(const NaClBitcodeHeaderField &)LLVM_DELETED_FUNCTION;
 
 public:
   // Defines the ID associated with the value. Valid values are in
   // {0x0, ..., 0xFFF}
   typedef enum {
-    kInvalid = 0,     // KUnknownType.
-    kPNaClVersion = 1 // kUint32.
+    kInvalid = 0,             // KUnknownType.
+    kPNaClVersion = 1,        // kUint32Type.
+    kAlignBitcodeRecords = 2, // kFlagType.
+    kTag_MAX = kAlignBitcodeRecords
   } Tag;
   // Defines the type of value.
   typedef enum {
     kBufferType, // Buffer of form uint8_t[len].
-    kUInt32Type
+    kUInt32Type,
+    kFlagType,
+    kUnknownType,
+    kFieldType_MAX = kUnknownType
   } FieldType;
   // Defines the number of bytes in a (32-bit) word.
   static const int WordSize = 4;
 
   // Defines the encoding of the fixed fields {i.e. ID:type and data length).
   typedef uint16_t FixedSubfield;
 
   // Create an invalid header field.
   NaClBitcodeHeaderField();
 
+  // Creates a header field where MyID is a flag.
+  NaClBitcodeHeaderField(Tag MyID);
+
   // Create a header field with an uint32_t value.
   NaClBitcodeHeaderField(Tag MyID, uint32_t value);
 
   // Create a header field for the given data.
   NaClBitcodeHeaderField(Tag MyID, size_t MyLen, uint8_t *MyData);
 
   virtual ~NaClBitcodeHeaderField() {
     if (Data)
       delete[] Data;
   }
 
   /// \brief Number of bytes used to represent header field.
   size_t GetTotalSize() const {
     // Round up to 4 byte alignment
     return (kTagLenSize + Len + (WordSize - 1)) & ~(WordSize - 1);
   }
 
   /// \brief Write field into Buf[BufLen].
   bool Write(uint8_t *Buf, size_t BufLen) const;
 
   /// \brief Read field from Buf[BufLen].
   bool Read(const uint8_t *Buf, size_t BufLen);
 
+  /// \brief Returns string describing ID of field.
+  static const char *IDName(Tag ID);
+  const char *IDName() const {
+    return IDName(ID);
+  }
+
+  /// \brief Returns string describing type of field.
+  static const char *TypeName(FieldType FType);
+  const char *TypeName() const {
+    return TypeName(FType);
+  }
+
   /// \brief Returns string describing field.
   std::string Contents() const;
 
   /// \brief Get the data size from a serialized field to allow allocation.
   static size_t GetDataSizeFromSerialized(const uint8_t *Buf) {
     FixedSubfield Length;
     ReadFixedSubfield(&Length, Buf + sizeof(FixedSubfield));
     return Length;
   }
 
@@ skipping 10 matching lines @@
 
   /// \brief Returns the uint32_t value stored. Requires that
   /// getType() == kUint32Type
   uint32_t GetUInt32Value() const;
 
 private:
   // Convert ID:Type into a fixed subfield
   FixedSubfield EncodeTypedID() const { return (ID << 4) | FType; }
   // Extract out ID and Type from a fixed subfield.
   void DecodeTypedID(FixedSubfield Subfield, Tag &ID, FieldType &FType) {
-    ID = static_cast<Tag>(Subfield >> 4);
-    FType = static_cast<FieldType>(Subfield & 0xF);
+    FixedSubfield PossibleID = Subfield >> 4;
+    ID = (PossibleID > kTag_MAX ? kInvalid : static_cast<Tag>(PossibleID));
+    FixedSubfield PossibleFType = Subfield & 0xF;
+    FType = (PossibleFType > kFieldType_MAX
+             ? kUnknownType : static_cast<FieldType>(PossibleFType));
   }
   // Combined size of the fixed subfields
   const static size_t kTagLenSize = 2 * sizeof(FixedSubfield);
   static void WriteFixedSubfield(FixedSubfield Value, uint8_t *Buf) {
     Buf[0] = Value & 0xFF;
     Buf[1] = (Value >> 8) & 0xFF;
   }
   static void ReadFixedSubfield(FixedSubfield *Value, const uint8_t *Buf) {
     *Value = Buf[0] | Buf[1] << 8;
   }
@@ skipping 14 matching lines @@
   // The number of bytes in the PNaCl header.
   size_t HeaderSize;
   // String defining why it is unsupported (if unsupported).
   std::string UnsupportedMessage;
   // Flag defining if header is supported.
   bool IsSupportedFlag;
   // Flag defining if the corresponding bitcode file is readable.
   bool IsReadableFlag;
   // Defines the PNaCl version defined by the header file.
   uint32_t PNaClVersion;
+  // Byte align bitcode records when nonzero.

[jvoung (off chromium), 2015/05/07 18:11:17]

Is this meant to say how much to align to (why uint32_t vs a bool)? Is that for
future expansion?

The field type is a "kFlagType" so you can't really specify an alignment amount
as is. Expansion would require making a different Tag with a different field
type.

[Karl, 2015/05/07 22:18:54]

My screw up. Always meant it to be a boolean flag. Fixing.

+  uint32_t AlignBitcodeRecords = 0;
 
 public:
   static const int WordSize = NaClBitcodeHeaderField::WordSize;
 
   NaClBitcodeHeader();
   ~NaClBitcodeHeader();
 
   /// \brief Installs the fields of the header, defining if the header
   /// is readable and supported. Sets UnsupportedMessage on failure.
   void InstallFields();
@@ skipping 45 matching lines @@
   /// (0 if no such field).
   NaClBitcodeHeaderField *GetTaggedField(NaClBitcodeHeaderField::Tag ID) const;
 
   /// \brief Returns a pointer to the Nth field in the header
   /// (0 if no such field).
   NaClBitcodeHeaderField *GetField(size_t index) const;
 
   /// \brief Returns the PNaClVersion, as defined by the header.
   uint32_t GetPNaClVersion() const { return PNaClVersion; }
 
+  /// \brief Returns if one should byte align bitcode records.
+  bool getAlignBitcodeRecords() const { return AlignBitcodeRecords; }
+
 private:
   // Reads and verifies the first 8 bytes of the header, consisting
   // of the magic number 'PEXE', and the value defining the number
   // of fields and number of bytes used to hold fields.
   // Returns false if successful, sets UnsupportedMessage otherwise.
   bool ReadPrefix(const unsigned char *BufPtr, const unsigned char *BufEnd,
                   unsigned &NumFields, unsigned &NumBytes);
 
   // Reads and verifies the fields in the header.
   // Returns false if successful, sets UnsupportedMessage otherwise.
   bool ReadFields(const unsigned char *BufPtr, const unsigned char *BufEnd,
                   unsigned NumFields, unsigned NumBytes);
 
   // Sets the Unsupported error message and returns true.
   bool UnsupportedError(StringRef Message) {
     UnsupportedMessage = Message.str();
     return true;
   }
 
 };
 
 } // namespace llvm
 
 #endif