| //===- 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/StreamingMemoryObject.h" |
| #include "llvm/Support/raw_ostream.h" |
| |
| #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) {} |
| |
| 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 |
| if (BufLen < FieldsLen + PadLen || |
| Len > std::numeric_limits<FixedSubfield>::max()) |
| return false; |
| |
| WriteFixedSubfield(EncodeTypedID(), Buf); |
| WriteFixedSubfield(static_cast<FixedSubfield>(Len), |
| Buf + sizeof(FixedSubfield)); |
| memcpy(Buf + kTagLenSize, Data, Len); |
| // Pad out to word alignment |
| if (PadLen) { |
| memset(Buf + FieldsLen, 0, PadLen); |
| } |
| return true; |
| } |
| |
| bool NaClBitcodeHeaderField::Read(const uint8_t *Buf, size_t BufLen) { |
| if (BufLen < kTagLenSize) |
| return false; |
| FixedSubfield IdField; |
| ReadFixedSubfield(&IdField, Buf); |
| FixedSubfield LengthField; |
| ReadFixedSubfield(&LengthField, Buf + sizeof(FixedSubfield)); |
| size_t Length = static_cast<size_t>(LengthField); |
| if (BufLen < kTagLenSize + Length) |
| return false; |
| if (Len != Length) { |
| // Need to reallocate data buffer. |
| if (Data) |
| delete[] Data; |
| Data = new uint8_t[Length]; |
| } |
| 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); |
| ss << IDName() << ": "; |
| switch (FType) { |
| case kFlagType: |
| ss << "true"; |
| break; |
| 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 |
| Iter = Fields.begin(), |
| IterEnd = Fields.end(); |
| Iter != IterEnd; ++Iter) { |
| delete *Iter; |
| } |
| } |
| |
| bool NaClBitcodeHeader::ReadPrefix(const unsigned char *BufPtr, |
| const unsigned char *BufEnd, |
| unsigned &NumFields, unsigned &NumBytes) { |
| // Must contain PEXE. |
| if (!isNaClBitcode(BufPtr, BufEnd)) { |
| UnsupportedMessage = "Invalid PNaCl bitcode header"; |
| if (isBitcode(BufPtr, BufEnd)) { |
| UnsupportedMessage += " (to run in Chrome, bitcode files must be " |
| "finalized using pnacl-finalize)"; |
| } |
| return true; |
| } |
| BufPtr += WordSize; |
| |
| // Read #Fields and number of bytes needed for the header. |
| if (BufPtr + WordSize > BufEnd) |
| return UnsupportedError("Bitcode read failure"); |
| NumFields = static_cast<unsigned>(BufPtr[0]) | |
| (static_cast<unsigned>(BufPtr[1]) << 8); |
| NumBytes = static_cast<unsigned>(BufPtr[2]) | |
| (static_cast<unsigned>(BufPtr[3]) << 8); |
| BufPtr += WordSize; |
| return false; |
| } |
| |
| bool NaClBitcodeHeader::ReadFields(const unsigned char *BufPtr, |
| const unsigned char *BufEnd, |
| unsigned NumFields, unsigned NumBytes) { |
| HeaderSize = NumBytes + (2 * WordSize); |
| |
| // Read in each field. |
| for (size_t i = 0; i < NumFields; ++i) { |
| 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) { |
| 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(); |
| return false; |
| } |
| |
| bool NaClBitcodeHeader::Read(MemoryObject *Bytes) { |
| unsigned NumFields; |
| unsigned NumBytes; |
| // First, read the prefix, which is 2 * WordSize, to determine the |
| // NumBytes and NumFields. |
| { |
| unsigned char Buffer[2 * WordSize]; |
| if (Bytes->readBytes(Buffer, sizeof(Buffer), 0) != sizeof(Buffer)) |
| return UnsupportedError("Bitcode read failure"); |
| if (ReadPrefix(Buffer, Buffer + sizeof(Buffer), NumFields, NumBytes)) |
| return true; // ReadPrefix sets UnsupportedMessage |
| } |
| // Then read the rest, starting after the 2 * WordSize of the prefix. |
| uint8_t *Header = new uint8_t[NumBytes]; |
| bool failed = Bytes->readBytes(Header, NumBytes, 2 * WordSize) != NumBytes || |
| ReadFields(Header, Header + NumBytes, NumFields, NumBytes); |
| delete[] Header; |
| if (failed) |
| return UnsupportedError("Bitcode read failure"); |
| InstallFields(); |
| return false; |
| } |
| |
| NaClBitcodeHeaderField * |
| NaClBitcodeHeader::GetTaggedField(NaClBitcodeHeaderField::Tag ID) const { |
| for (std::vector<NaClBitcodeHeaderField *>::const_iterator |
| Iter = Fields.begin(), |
| IterEnd = Fields.end(); |
| Iter != IterEnd; ++Iter) { |
| if ((*Iter)->GetID() == ID) { |
| return *Iter; |
| } |
| } |
| return 0; |
| } |
| |
| NaClBitcodeHeaderField *NaClBitcodeHeader::GetField(size_t index) const { |
| if (index >= Fields.size()) |
| return 0; |
| return Fields[index]; |
| } |
| |
| NaClBitcodeHeaderField *GetPNaClVersionPtr(NaClBitcodeHeader *Header) { |
| if (NaClBitcodeHeaderField *Version = |
| Header->GetTaggedField(NaClBitcodeHeaderField::kPNaClVersion)) { |
| if (Version->GetType() == NaClBitcodeHeaderField::kUInt32Type) { |
| return Version; |
| } |
| } |
| return 0; |
| } |
| |
| void NaClBitcodeHeader::InstallFields() { |
| IsSupportedFlag = true; |
| IsReadableFlag = true; |
| AlignBitcodeRecords = false; |
| PNaClVersion = 0; |
| UnsupportedMessage.clear(); |
| SmallSet<unsigned, NaClBitcodeHeaderField::kTag_MAX> FieldIDs; |
| |
| auto ReportProblem = [&](bool IsReadable) { |
| UnsupportedMessage.append("\n"); |
| IsSupportedFlag = false; |
| IsReadableFlag = IsReadableFlag && IsReadable; |
| }; |
| |
| auto ReportProblemWithContents = [&](NaClBitcodeHeaderField *Field, |
| bool IsReadable) { |
| 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(false); |
| continue; |
| } |
| NaClBitcodeHeaderField::FieldType ExpectedTy = ExpectedType[Field->GetID()]; |
| if (Field->GetType() != ExpectedTy) { |
| UnsupportedMessage.append("Expects type "); |
| UnsupportedMessage.append(NaClBitcodeHeaderField::TypeName(ExpectedTy)); |
| ReportProblemWithContents(Field, false); |
| continue; |
| } |
| if (Field->GetType() == NaClBitcodeHeaderField::kUnknownType) { |
| UnsupportedMessage.append("Unknown value"); |
| ReportProblemWithContents(Field, false); |
| continue; |
| } |
| |
| // Check specific ID values and install. |
| switch (Field->GetID()) { |
| case NaClBitcodeHeaderField::kInvalid: |
| UnsupportedMessage.append("Unsupported"); |
| ReportProblemWithContents(Field, false); |
| continue; |
| case NaClBitcodeHeaderField::kPNaClVersion: |
| PNaClVersion = Field->GetUInt32Value(); |
| if (PNaClVersion != 2) { |
| UnsupportedMessage.append("Unsupported"); |
| ReportProblemWithContents(Field, false); |
| continue; |
| } |
| break; |
| case NaClBitcodeHeaderField::kAlignBitcodeRecords: |
| AlignBitcodeRecords = true; |
| UnsupportedMessage.append("Unsupported"); |
| ReportProblemWithContents(Field, true); |
| continue; |
| } |
| } |
| } |