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.
448 lines
14 KiB
448 lines
14 KiB
//===- 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.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/Bitcode/NaCl/NaClBitstreamReader.h"
|
|
#include "llvm/ADT/STLExtras.h"
|
|
#include "llvm/Support/Format.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
|
|
using namespace llvm;
|
|
|
|
namespace {
|
|
|
|
static const char *ErrorLevelName[] = {"Warning", "Error", "Fatal"};
|
|
|
|
} // End of anonymous namespace.
|
|
|
|
std::string llvm::naclbitc::getBitAddress(uint64_t Bit) {
|
|
std::string Buffer;
|
|
raw_string_ostream Stream(Buffer);
|
|
Stream << (Bit / 8) << ":" << (Bit % 8);
|
|
return Stream.str();
|
|
}
|
|
|
|
raw_ostream &llvm::naclbitc::ErrorAt(raw_ostream &Out, ErrorLevel Level,
|
|
uint64_t BitPosition) {
|
|
assert(Level < array_lengthof(::ErrorLevelName));
|
|
return Out << ErrorLevelName[Level] << "("
|
|
<< naclbitc::getBitAddress(BitPosition) << "): ";
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// NaClBitstreamCursor implementation
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
void NaClBitstreamCursor::ErrorHandler::Fatal(
|
|
const std::string &ErrorMessage) const {
|
|
// Default implementation is simply print message, and the bit where
|
|
// the error occurred.
|
|
std::string Buffer;
|
|
raw_string_ostream StrBuf(Buffer);
|
|
naclbitc::ErrorAt(StrBuf, naclbitc::Fatal,
|
|
Cursor.getErrorBitNo(getCurrentBitNo()))
|
|
<< ErrorMessage;
|
|
report_fatal_error(StrBuf.str());
|
|
}
|
|
|
|
void NaClBitstreamCursor::reportInvalidAbbrevNumber(unsigned AbbrevNo) const {
|
|
std::string Buffer;
|
|
raw_string_ostream StrBuf(Buffer);
|
|
StrBuf << "Invalid abbreviation # " << AbbrevNo << " defined for record";
|
|
ErrHandler->Fatal(StrBuf.str());
|
|
}
|
|
|
|
void NaClBitstreamCursor::reportInvalidJumpToBit(uint64_t BitNo) const {
|
|
std::string Buffer;
|
|
raw_string_ostream StrBuf(Buffer);
|
|
StrBuf << "Invalid jump to bit " << BitNo;
|
|
ErrHandler->Fatal(StrBuf.str());
|
|
}
|
|
|
|
/// EnterSubBlock - Having read the ENTER_SUBBLOCK abbrevid, enter
|
|
/// the block, and return true if the block has an error.
|
|
bool NaClBitstreamCursor::EnterSubBlock(unsigned BlockID, unsigned *NumWordsP) {
|
|
const bool IsFixed = true;
|
|
NaClBitcodeSelectorAbbrev CodeAbbrev(IsFixed,
|
|
ReadVBR(naclbitc::CodeLenWidth));
|
|
BlockScope.push_back(Block(BitStream->getBlockInfo(BlockID), CodeAbbrev));
|
|
SkipToFourByteBoundary();
|
|
unsigned NumWords = Read(naclbitc::BlockSizeWidth);
|
|
if (NumWordsP)
|
|
*NumWordsP = NumWords;
|
|
|
|
// Validate that this block is sane.
|
|
if (BlockScope.back().getCodeAbbrev().NumBits == 0 || AtEndOfStream())
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
void NaClBitstreamCursor::skipAbbreviatedField(const NaClBitCodeAbbrevOp &Op) {
|
|
// Decode the value as we are commanded.
|
|
switch (Op.getEncoding()) {
|
|
case NaClBitCodeAbbrevOp::Literal:
|
|
// No read necessary for literal.
|
|
break;
|
|
case NaClBitCodeAbbrevOp::Fixed:
|
|
(void)Read((unsigned)Op.getValue());
|
|
break;
|
|
case NaClBitCodeAbbrevOp::VBR:
|
|
(void)ReadVBR64((unsigned)Op.getValue());
|
|
break;
|
|
case NaClBitCodeAbbrevOp::Array:
|
|
// This can't happen because the abbreviation must be valid.
|
|
llvm_unreachable("Bad array abbreviation encoding!");
|
|
break;
|
|
case NaClBitCodeAbbrevOp::Char6:
|
|
(void)Read(6);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/// 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.
|
|
Value = ReadVBR(6);
|
|
return true;
|
|
case NaClBitCodeAbbrevOp::Fixed:
|
|
Value = Read((unsigned)Op.getValue());
|
|
break;
|
|
case NaClBitCodeAbbrevOp::VBR:
|
|
Value = ReadVBR64((unsigned)Op.getValue());
|
|
break;
|
|
case NaClBitCodeAbbrevOp::Char6:
|
|
Value = NaClBitCodeAbbrevOp::DecodeChar6(Read(6));
|
|
break;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
uint64_t
|
|
NaClBitstreamCursor::readArrayAbbreviatedField(const NaClBitCodeAbbrevOp &Op) {
|
|
// Decode the value as we are commanded.
|
|
switch (Op.getEncoding()) {
|
|
case NaClBitCodeAbbrevOp::Literal:
|
|
return Op.getValue();
|
|
case NaClBitCodeAbbrevOp::Fixed:
|
|
return Read((unsigned)Op.getValue());
|
|
case NaClBitCodeAbbrevOp::VBR:
|
|
return ReadVBR64((unsigned)Op.getValue());
|
|
case NaClBitCodeAbbrevOp::Array:
|
|
// This can't happen because the abbreviation must be valid.
|
|
llvm_unreachable("Bad array abbreviation encoding!");
|
|
break;
|
|
case NaClBitCodeAbbrevOp::Char6:
|
|
return NaClBitCodeAbbrevOp::DecodeChar6(Read(6));
|
|
}
|
|
llvm_unreachable("Illegal abbreviation encoding for field!");
|
|
}
|
|
|
|
void NaClBitstreamCursor::readArrayAbbrev(const NaClBitCodeAbbrevOp &Op,
|
|
unsigned NumArrayElements,
|
|
SmallVectorImpl<uint64_t> &Vals) {
|
|
for (; NumArrayElements; --NumArrayElements) {
|
|
Vals.push_back(readArrayAbbreviatedField(Op));
|
|
}
|
|
}
|
|
|
|
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: "
|
|
<< Value;
|
|
ErrHandler->Fatal(StrBuf.str());
|
|
}
|
|
return NaClBitCodeAbbrevOp::Encoding(Value);
|
|
}
|
|
|
|
void NaClBitstreamCursor::ReadAbbrevRecord(bool IsLocal,
|
|
NaClAbbrevListener *Listener) {
|
|
NaClBitCodeAbbrev *Abbv = BlockScope.back().appendLocalCreate();
|
|
unsigned NumOpInfo = ReadVBR(5);
|
|
if (Listener)
|
|
Listener->Values.push_back(NumOpInfo);
|
|
for (unsigned i = 0; i != NumOpInfo; ++i) {
|
|
bool IsLiteral = Read(1) ? true : false;
|
|
if (Listener)
|
|
Listener->Values.push_back(IsLiteral);
|
|
if (IsLiteral) {
|
|
uint64_t Value = ReadVBR64(8);
|
|
if (Listener)
|
|
Listener->Values.push_back(Value);
|
|
Abbv->Add(NaClBitCodeAbbrevOp(Value));
|
|
continue;
|
|
}
|
|
NaClBitCodeAbbrevOp::Encoding E = getEncoding(Read(3));
|
|
if (Listener)
|
|
Listener->Values.push_back(E);
|
|
if (NaClBitCodeAbbrevOp::hasValue(E)) {
|
|
unsigned Data = ReadVBR64(5);
|
|
if (Listener)
|
|
Listener->Values.push_back(Data);
|
|
|
|
// As a special case, handle fixed(0) (i.e., a fixed field with zero bits)
|
|
// and vbr(0) as a literal zero. This is decoded the same way, and avoids
|
|
// a slow path in Read() to have to handle reading zero bits.
|
|
if ((E == NaClBitCodeAbbrevOp::Fixed || E == NaClBitCodeAbbrevOp::VBR) &&
|
|
Data == 0) {
|
|
if (Listener)
|
|
Listener->Values.push_back(0);
|
|
Abbv->Add(NaClBitCodeAbbrevOp(0));
|
|
continue;
|
|
}
|
|
if (!NaClBitCodeAbbrevOp::isValid(E, Data)) {
|
|
std::string Buffer;
|
|
raw_string_ostream StrBuf(Buffer);
|
|
StrBuf << "Invalid abbreviation encoding ("
|
|
<< NaClBitCodeAbbrevOp::getEncodingName(E) << ", " << Data
|
|
<< ")";
|
|
ErrHandler->Fatal(StrBuf.str());
|
|
}
|
|
Abbv->Add(NaClBitCodeAbbrevOp(E, Data));
|
|
} else {
|
|
if (!NaClBitCodeAbbrevOp::isValid(E)) {
|
|
std::string Buffer;
|
|
raw_string_ostream StrBuf(Buffer);
|
|
StrBuf << "Invalid abbreviation encoding ("
|
|
<< NaClBitCodeAbbrevOp::getEncodingName(E) << ")";
|
|
ErrHandler->Fatal(StrBuf.str());
|
|
}
|
|
Abbv->Add(NaClBitCodeAbbrevOp(E));
|
|
}
|
|
}
|
|
SkipToByteBoundaryIfAligned();
|
|
if (!Abbv->isValid())
|
|
ErrHandler->Fatal("Invalid abbreviation specified in bitcode file");
|
|
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();
|
|
}
|
|
|
|
namespace {
|
|
|
|
unsigned ValidBlockIDs[] = {
|
|
naclbitc::BLOCKINFO_BLOCK_ID, naclbitc::CONSTANTS_BLOCK_ID,
|
|
naclbitc::FUNCTION_BLOCK_ID, naclbitc::GLOBALVAR_BLOCK_ID,
|
|
naclbitc::MODULE_BLOCK_ID, naclbitc::TOP_LEVEL_BLOCKID,
|
|
naclbitc::TYPE_BLOCK_ID_NEW, naclbitc::VALUE_SYMTAB_BLOCK_ID};
|
|
|
|
} // end of anonymous namespace
|
|
|
|
NaClBitstreamReader::BlockInfoRecordsMap::BlockInfoRecordsMap()
|
|
: IsFrozen(false) {
|
|
for (size_t BlockID : ValidBlockIDs) {
|
|
std::unique_ptr<BlockInfo> Info(new BlockInfo(BlockID));
|
|
KnownInfos.emplace(BlockID, std::move(Info));
|
|
}
|
|
}
|
|
|
|
NaClBitstreamReader::BlockInfo *
|
|
NaClBitstreamReader::BlockInfoRecordsMap::getOrCreateUnknownBlockInfo(
|
|
unsigned BlockID) {
|
|
std::unique_lock<std::mutex> Lock(UnknownBlockInfoLock);
|
|
while (true) {
|
|
auto Pos = UnknownInfos.find(BlockID);
|
|
if (Pos != UnknownInfos.end())
|
|
return Pos->second.get();
|
|
// Install, then let next iteration find.
|
|
std::unique_ptr<BlockInfo> Info(new BlockInfo(BlockID));
|
|
UnknownInfos.emplace(BlockID, std::move(Info));
|
|
}
|
|
}
|
|
|
|
NaClBitstreamReader::BlockInfoRecordsMap::UpdateLock::UpdateLock(
|
|
BlockInfoRecordsMap &BlockInfoRecords)
|
|
: BlockInfoRecords(BlockInfoRecords),
|
|
Lock(BlockInfoRecords.UpdateRecordsLock) {}
|
|
|
|
NaClBitstreamReader::BlockInfoRecordsMap::UpdateLock::~UpdateLock() {
|
|
if (BlockInfoRecords.freeze())
|
|
report_fatal_error("Global abbreviations block frozen while building.");
|
|
}
|
|
|
|
bool NaClBitstreamCursor::ReadBlockInfoBlock(NaClAbbrevListener *Listener) {
|
|
// If this is the second read of the block info block, skip it.
|
|
if (BitStream->BlockInfoRecords->isFrozen())
|
|
return SkipBlock();
|
|
|
|
NaClBitstreamReader::BlockInfoRecordsMap::UpdateLock Lock(
|
|
*BitStream->BlockInfoRecords);
|
|
unsigned NumWords;
|
|
if (EnterSubBlock(naclbitc::BLOCKINFO_BLOCK_ID, &NumWords))
|
|
return true;
|
|
|
|
if (Listener)
|
|
Listener->BeginBlockInfoBlock(NumWords);
|
|
|
|
NaClBitcodeRecordVector Record;
|
|
Block &CurBlock = BlockScope.back();
|
|
NaClBitstreamReader::AbbrevList *UpdateAbbrevs =
|
|
&CurBlock.GlobalAbbrevs->getAbbrevs();
|
|
bool FoundSetBID = false;
|
|
|
|
// Read records of the BlockInfo block.
|
|
while (1) {
|
|
if (Listener)
|
|
Listener->StartBit = GetCurrentBitNo();
|
|
NaClBitstreamEntry Entry = advance(AF_DontAutoprocessAbbrevs, Listener);
|
|
|
|
switch (Entry.Kind) {
|
|
case llvm::NaClBitstreamEntry::SubBlock: // PNaCl doesn't allow!
|
|
case llvm::NaClBitstreamEntry::Error:
|
|
return true;
|
|
case llvm::NaClBitstreamEntry::EndBlock:
|
|
if (Listener)
|
|
Listener->EndBlockInfoBlock();
|
|
return false;
|
|
case llvm::NaClBitstreamEntry::Record:
|
|
// The interesting case.
|
|
break;
|
|
}
|
|
|
|
// Read abbrev records, associate them with CurBID.
|
|
if (Entry.ID == naclbitc::DEFINE_ABBREV) {
|
|
ReadAbbrevRecord(false, Listener);
|
|
|
|
// ReadAbbrevRecord installs a local abbreviation. Move it to the
|
|
// appropriate BlockInfo if the corresponding SetBID record has been
|
|
// found.
|
|
if (FoundSetBID)
|
|
CurBlock.moveLocalAbbrevToAbbrevList(UpdateAbbrevs);
|
|
continue;
|
|
}
|
|
|
|
// Read a record.
|
|
Record.clear();
|
|
switch (readRecord(Entry.ID, Record)) {
|
|
default:
|
|
// No other records should be found!
|
|
return true;
|
|
case naclbitc::BLOCKINFO_CODE_SETBID:
|
|
if (Record.size() < 1)
|
|
return true;
|
|
FoundSetBID = true;
|
|
UpdateAbbrevs =
|
|
&BitStream->getBlockInfo((unsigned)Record[0])->getAbbrevs();
|
|
if (Listener) {
|
|
Listener->Values = Record;
|
|
Listener->SetBID();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|