You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
351 lines
11 KiB
351 lines
11 KiB
//===- 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;
|
|
}
|
|
}
|
|
}
|