Index: src/PNaClTranslator.cpp |
diff --git a/src/PNaClTranslator.cpp b/src/PNaClTranslator.cpp |
new file mode 100644 |
index 0000000000000000000000000000000000000000..82ef5ac4695ec9342c16d58026301eca4ddfdb5f |
--- /dev/null |
+++ b/src/PNaClTranslator.cpp |
@@ -0,0 +1,859 @@ |
+//===- subzero/src/PNaClTranslator.cpp - ICE from bitcode -----------------===// |
+// |
+// The Subzero Code Generator |
+// |
+// This file is distributed under the University of Illinois Open Source |
+// License. See LICENSE.TXT for details. |
+// |
+//===----------------------------------------------------------------------===// |
+// |
+// This file implements the PNaCl bitcode file to Ice, to machine code |
+// translator. |
+// |
+//===----------------------------------------------------------------------===// |
+ |
+#include "PNaClTranslator.h" |
+#include "IceCfg.h" |
+#include "llvm/Bitcode/NaCl/NaClBitcodeDecoders.h" |
+#include "llvm/Bitcode/NaCl/NaClBitcodeHeader.h" |
+#include "llvm/Bitcode/NaCl/NaClBitcodeParser.h" |
+#include "llvm/Bitcode/NaCl/NaClReaderWriter.h" |
+#include "llvm/IR/Constants.h" |
+#include "llvm/IR/LLVMContext.h" |
+#include "llvm/IR/Module.h" |
+#include "llvm/Support/Format.h" |
+#include "llvm/Support/MemoryBuffer.h" |
+#include "llvm/Support/raw_ostream.h" |
+#include "llvm/Support/ValueHandle.h" |
+ |
+#include <vector> |
+#include <cassert> |
+ |
+using namespace llvm; |
+ |
+namespace { |
+ |
+// Top-level class to read PNaCl bitcode files, and translate to ICE. |
+class TopLevelParser : public NaClBitcodeParser { |
+ TopLevelParser(const TopLevelParser &) LLVM_DELETED_FUNCTION; |
+ TopLevelParser &operator=(const TopLevelParser &) LLVM_DELETED_FUNCTION; |
+ |
+public: |
+ TopLevelParser(const std::string &InputName, NaClBitcodeHeader &Header, |
+ NaClBitstreamCursor &Cursor, int &ExitStatusFlag) |
+ : NaClBitcodeParser(Cursor), |
+ Mod(new Module(InputName, getGlobalContext())), Header(Header), |
+ ExitStatusFlag(ExitStatusFlag), NumErrors(0), NumFunctionIds(0), |
+ GlobalVarPlaceHolderType(Type::getInt8Ty(getLLVMContext())) { |
+ Mod->setDataLayout(PNaClDataLayout); |
+ } |
+ |
+ virtual ~TopLevelParser() {} |
+ LLVM_OVERRIDE; |
+ |
+ virtual bool Error(const std::string &Message) LLVM_OVERRIDE { |
+ ExitStatusFlag = 1; |
+ ++NumErrors; |
+ return NaClBitcodeParser::Error(Message); |
+ } |
+ |
+ /// Returns the number of errors found while parsing the bitcode |
+ /// file. |
+ unsigned getNumErrors() const { return NumErrors; } |
+ |
+ /// Returns the LLVM module associated with the translation. |
+ Module *getModule() const { return Mod.get(); } |
+ |
+ /// Returns the number of bytes in the bitcode header. |
+ size_t getHeaderSize() const { return Header.getHeaderSize(); } |
+ |
+ /// Returns the llvm context to use. |
+ LLVMContext &getLLVMContext() const { return Mod->getContext(); } |
+ |
+ /// Changes the size of the type list to the given size. |
+ void resizeTypeIDValues(unsigned NewSize) { TypeIDValues.resize(NewSize); } |
+ |
+ /// Returns the type associated with the given index. |
+ Type *getTypeByID(unsigned ID) { |
+ // Note: method resizeTypeIDValues expands TypeIDValues |
+ // to the specified size, and fills elements with NULL. |
+ Type *Ty = ID < TypeIDValues.size() ? TypeIDValues[ID] : NULL; |
+ if (Ty) |
+ return Ty; |
+ return reportTypeIDAsUndefined(ID); |
+ } |
+ |
+ /// Defines type for ID. |
+ void setTypeID(unsigned ID, Type *Ty) { |
+ if (ID < TypeIDValues.size() && TypeIDValues[ID] == NULL) { |
+ TypeIDValues[ID] = Ty; |
+ return; |
+ } |
+ reportBadSetTypeID(ID, Ty); |
+ } |
+ |
+ /// Sets the next function ID to the given LLVM function. |
+ void setNextFunctionID(Function *Fcn) { |
+ ++NumFunctionIds; |
+ ValueIDValues.push_back(Fcn); |
+ } |
+ |
+ /// Defines the next function ID as one that has an implementation |
+ /// (i.e a corresponding function block in the bitcode). |
+ void setNextValueIDAsImplementedFunction() { |
+ DefiningFunctionsList.push_back(ValueIDValues.size()); |
+ } |
+ |
+ /// Returns the LLVM IR value associatd with the global value ID. |
+ Value *getGlobalValueByID(unsigned ID) const { |
+ if (ID >= ValueIDValues.size()) |
+ return 0; |
+ return ValueIDValues[ID]; |
+ } |
+ |
+ /// Returns the number of function addresses (i.e. ID's) defined in |
+ /// the bitcode file. |
+ unsigned getNumFunctionIDs() const { return NumFunctionIds; } |
+ |
+ /// Returns the number of global values defined in the bitcode |
+ /// file. |
+ unsigned getNumGlobalValueIDs() const { return ValueIDValues.size(); } |
+ |
+ /// Resizes the list of value IDs to include Count global variable |
+ /// IDs. |
+ void resizeValueIDsForGlobalVarCount(unsigned Count) { |
+ ValueIDValues.resize(ValueIDValues.size() + Count); |
+ } |
+ |
+ /// Returns the global variable address associated with the given |
+ /// value ID. If the ID refers to a global variable address not yet |
+ /// defined, a placeholder is created so that we can fix it up |
+ /// later. |
+ Constant *getOrCreateGlobalVarRef(unsigned ID) { |
+ if (ID >= ValueIDValues.size()) |
+ return 0; |
+ if (Value *C = ValueIDValues[ID]) |
+ return dyn_cast<Constant>(C); |
+ Constant *C = new GlobalVariable(*Mod, GlobalVarPlaceHolderType, false, |
+ GlobalValue::ExternalLinkage, 0); |
+ ValueIDValues[ID] = C; |
+ return C; |
+ } |
+ |
+ /// Assigns the given global variable (address) to the given value |
+ /// ID. Returns true if ID is a valid global variable ID. Otherwise |
+ /// returns false. |
+ bool assignGlobalVariable(GlobalVariable *GV, unsigned ID) { |
+ if (ID < NumFunctionIds || ID >= ValueIDValues.size()) |
+ return false; |
+ WeakVH &OldV = ValueIDValues[ID]; |
+ if (OldV == 0) { |
+ ValueIDValues[ID] = GV; |
+ return true; |
+ } |
+ |
+ // If reached, there was a forward reference to this value. Replace it. |
+ Value *PrevVal = OldV; |
+ GlobalVariable *Placeholder = cast<GlobalVariable>(PrevVal); |
+ Placeholder->replaceAllUsesWith( |
+ ConstantExpr::getBitCast(GV, Placeholder->getType())); |
+ Placeholder->eraseFromParent(); |
+ ValueIDValues[ID] = GV; |
+ return true; |
+ } |
+ |
+private: |
+ // The parsed module. |
+ OwningPtr<Module> Mod; |
+ // The bitcode header. |
+ NaClBitcodeHeader &Header; |
+ // The exit status flag that should be set to 1 if an error occurs. |
+ int &ExitStatusFlag; |
+ // The number of errors reported. |
+ unsigned NumErrors; |
+ // The types associated with each type ID. |
+ std::vector<Type *> TypeIDValues; |
+ // The (global) value IDs. |
+ std::vector<WeakVH> ValueIDValues; |
+ // The number of function IDs. |
+ unsigned NumFunctionIds; |
+ // The list of value IDs (in the order found) of defining function |
+ // addresses. |
+ std::vector<unsigned> DefiningFunctionsList; |
+ // Cached global variable placeholder type. Used for all forward |
+ // references to global variable addresses. |
+ Type *GlobalVarPlaceHolderType; |
+ |
+ virtual bool ParseBlock(unsigned BlockID) LLVM_OVERRIDE; |
+ |
+ /// Reports that type ID is undefined, and then returns |
+ /// the void type. |
+ Type *reportTypeIDAsUndefined(unsigned ID); |
+ |
+ /// Reports error about bad call to setTypeID. |
+ void reportBadSetTypeID(unsigned ID, Type *Ty); |
+}; |
+ |
+Type *TopLevelParser::reportTypeIDAsUndefined(unsigned ID) { |
+ std::string Buffer; |
+ raw_string_ostream StrBuf(Buffer); |
+ StrBuf << "Can't find type for type id: " << ID; |
+ Error(StrBuf.str()); |
+ Type *Ty = Type::getVoidTy(getLLVMContext()); |
+ // To reduce error messages, update type list if possible. |
+ if (ID < TypeIDValues.size()) |
+ TypeIDValues[ID] = Ty; |
+ return Ty; |
+} |
+ |
+void TopLevelParser::reportBadSetTypeID(unsigned ID, Type *Ty) { |
+ std::string Buffer; |
+ raw_string_ostream StrBuf(Buffer); |
+ if (ID >= TypeIDValues.size()) { |
+ StrBuf << "Type index " << ID << " out of range: can't install."; |
+ } else { |
+ // Must be case that index already defined. |
+ StrBuf << "Type index " << ID << " defined as " << *TypeIDValues[ID] |
+ << " and " << *Ty << "."; |
+ } |
+ Error(StrBuf.str()); |
+} |
+ |
+// Base class for parsing blocks within the bitcode file. Note: |
+// Because this is the base class of block parsers, we generate error |
+// messages if ParseBlock or ParseRecord is not overridden in derived |
+// classes. |
+class BlockParserBaseClass : public NaClBitcodeParser { |
+public: |
+ // Constructor for the top-level module block parser. |
+ BlockParserBaseClass(unsigned BlockID, TopLevelParser *Context) |
+ : NaClBitcodeParser(BlockID, Context), Context(Context) {} |
+ |
+ virtual ~BlockParserBaseClass() LLVM_OVERRIDE {} |
+ |
+protected: |
+ // The context parser that contains the decoded state. |
+ TopLevelParser *Context; |
+ |
+ // Constructor for nested block parsers. |
+ BlockParserBaseClass(unsigned BlockID, BlockParserBaseClass *EnclosingParser) |
+ : NaClBitcodeParser(BlockID, EnclosingParser), |
+ Context(EnclosingParser->Context) {} |
+ |
+ // Generates an error Message with the bit address prefixed to it. |
+ virtual bool Error(const std::string &Message) LLVM_OVERRIDE { |
+ uint64_t Bit = Record.GetStartBit() + Context->getHeaderSize() * 8; |
+ std::string Buffer; |
+ raw_string_ostream StrBuf(Buffer); |
+ StrBuf << "(" << format("%" PRIu64 ":%u", (Bit / 8), |
+ static_cast<unsigned>(Bit % 8)) << ") " << Message; |
+ return Context->Error(StrBuf.str()); |
+ } |
+ |
+ // Default implementation. Reports that block is unknown and skips |
+ // its contents. |
+ virtual bool ParseBlock(unsigned BlockID) LLVM_OVERRIDE; |
+ |
+ // Default implementation. Reports that the record is not |
+ // understood. |
+ virtual void ProcessRecord() LLVM_OVERRIDE; |
+ |
+ /// Checks if the size of the record is Size. If not, an error is |
+ /// produced using the given RecordName. Return true if error was |
+ /// reported. Otherwise false. |
+ bool checkRecordSize(unsigned Size, const char *RecordName) { |
+ const NaClBitcodeRecord::RecordVector &Values = Record.GetValues(); |
+ if (Values.size() != Size) { |
+ return RecordSizeError(Size, RecordName, 0); |
+ } |
+ return false; |
+ } |
+ |
+ /// Checks if the size of the record is at least as large as the |
+ /// LowerLimit. |
+ bool checkRecordSizeAtLeast(unsigned LowerLimit, const char *RecordName) { |
+ const NaClBitcodeRecord::RecordVector &Values = Record.GetValues(); |
+ if (Values.size() < LowerLimit) { |
+ return RecordSizeError(LowerLimit, RecordName, "at least"); |
+ } |
+ return false; |
+ } |
+ |
+ /// Checks if the size of the record is no larger than the |
+ /// UpperLimit. |
+ bool checkRecordSizeNoMoreThan(unsigned UpperLimit, const char *RecordName) { |
+ const NaClBitcodeRecord::RecordVector &Values = Record.GetValues(); |
+ if (Values.size() > UpperLimit) { |
+ return RecordSizeError(UpperLimit, RecordName, "no more than"); |
+ } |
+ return false; |
+ } |
+ |
+ /// Checks if the size of the record is at least as large as the |
+ /// LowerLimit, and no larger than the UpperLimit. |
+ bool checkRecordSizeInRange(unsigned LowerLimit, unsigned UpperLimit, |
+ const char *RecordName) { |
+ return checkRecordSizeAtLeast(LowerLimit, RecordName) || |
+ checkRecordSizeNoMoreThan(UpperLimit, RecordName); |
+ } |
+ |
+private: |
+ /// Generates a record size error. ExpectedSize is the number |
+ /// of elements expected. RecordName is the name of the kind of |
+ /// record that has incorrect size. ContextMessage (if not 0) |
+ /// is appended to "record expects" to describe how ExpectedSize |
+ /// should be interpreted. |
+ bool RecordSizeError(unsigned ExpectedSize, const char *RecordName, |
+ const char *ContextMessage) { |
+ std::string Buffer; |
+ raw_string_ostream StrBuf(Buffer); |
+ StrBuf << RecordName << " record expects"; |
+ if (ContextMessage) |
+ StrBuf << " " << ContextMessage; |
+ StrBuf << " " << ExpectedSize << " argument"; |
+ if (ExpectedSize > 1) |
+ StrBuf << "s"; |
+ StrBuf << ". Found: " << Record.GetValues().size(); |
+ return Error(StrBuf.str()); |
+ } |
+}; |
+ |
+bool BlockParserBaseClass::ParseBlock(unsigned BlockID) { |
+ // If called, derived class doesn't know how to handle block. |
+ // Report error and skip. |
+ std::string Buffer; |
+ raw_string_ostream StrBuf(Buffer); |
+ StrBuf << "Don't know how to parse block id: " << BlockID; |
+ Error(StrBuf.str()); |
+ SkipBlock(); |
+ return false; |
+} |
+ |
+void BlockParserBaseClass::ProcessRecord() { |
+ // If called, derived class doesn't know how to handle. |
+ std::string Buffer; |
+ raw_string_ostream StrBuf(Buffer); |
+ StrBuf << "Don't know how to process record: " << Record; |
+ Error(StrBuf.str()); |
+} |
+ |
+// Class to parse a types block. |
+class TypesParser : public BlockParserBaseClass { |
+public: |
+ TypesParser(unsigned BlockID, BlockParserBaseClass *EnclosingParser) |
+ : BlockParserBaseClass(BlockID, EnclosingParser), NextTypeId(0) {} |
+ |
+ ~TypesParser() LLVM_OVERRIDE {} |
+ |
+private: |
+ // The type ID that will be associated with the next type defining |
+ // record in the types block. |
+ unsigned NextTypeId; |
+ |
+ virtual void ProcessRecord() LLVM_OVERRIDE; |
+}; |
+ |
+void TypesParser::ProcessRecord() { |
+ Type *Ty = NULL; |
+ const NaClBitcodeRecord::RecordVector &Values = Record.GetValues(); |
+ switch (Record.GetCode()) { |
+ case naclbitc::TYPE_CODE_NUMENTRY: |
+ // NUMENTRY: [numentries] |
+ if (checkRecordSize(1, "Type count")) |
+ return; |
+ Context->resizeTypeIDValues(Values[0]); |
+ return; |
+ case naclbitc::TYPE_CODE_VOID: |
+ // VOID |
+ if (checkRecordSize(0, "Type void")) |
+ break; |
+ Ty = Type::getVoidTy(Context->getLLVMContext()); |
+ break; |
+ case naclbitc::TYPE_CODE_FLOAT: |
+ // FLOAT |
+ if (checkRecordSize(0, "Type float")) |
+ break; |
+ Ty = Type::getFloatTy(Context->getLLVMContext()); |
+ break; |
+ case naclbitc::TYPE_CODE_DOUBLE: |
+ // DOUBLE |
+ if (checkRecordSize(0, "Type double")) |
+ break; |
+ Ty = Type::getDoubleTy(Context->getLLVMContext()); |
+ break; |
+ case naclbitc::TYPE_CODE_INTEGER: |
+ // INTEGER: [width] |
+ if (checkRecordSize(1, "Type integer")) |
+ break; |
+ Ty = IntegerType::get(Context->getLLVMContext(), Values[0]); |
+ // TODO(kschimpf) Check if size is legal. |
+ break; |
+ case naclbitc::TYPE_CODE_VECTOR: |
+ // VECTOR: [numelts, eltty] |
+ if (checkRecordSize(2, "Type vector")) |
+ break; |
+ Ty = VectorType::get(Context->getTypeByID(Values[1]), Values[0]); |
+ break; |
+ case naclbitc::TYPE_CODE_FUNCTION: { |
+ // FUNCTION: [vararg, retty, paramty x N] |
+ if (checkRecordSizeAtLeast(2, "Type signature")) |
+ break; |
+ SmallVector<Type *, 8> ArgTys; |
+ for (unsigned i = 2, e = Values.size(); i != e; ++i) { |
+ ArgTys.push_back(Context->getTypeByID(Values[i])); |
+ } |
+ Ty = FunctionType::get(Context->getTypeByID(Values[1]), ArgTys, Values[0]); |
+ break; |
+ } |
+ default: |
+ BlockParserBaseClass::ProcessRecord(); |
+ break; |
+ } |
+ // If Ty not defined, assume error. Use void as filler. |
+ if (Ty == NULL) |
+ Ty = Type::getVoidTy(Context->getLLVMContext()); |
+ Context->setTypeID(NextTypeId++, Ty); |
+} |
+ |
+/// Parses the globals block (i.e. global variables). |
+class GlobalsParser : public BlockParserBaseClass { |
+public: |
+ GlobalsParser(unsigned BlockID, BlockParserBaseClass *EnclosingParser) |
+ : BlockParserBaseClass(BlockID, EnclosingParser), InitializersNeeded(0), |
+ Alignment(1), IsConstant(false) { |
+ NextGlobalID = Context->getNumFunctionIDs(); |
+ } |
+ |
+ virtual ~GlobalsParser() LLVM_OVERRIDE {} |
+ |
+private: |
+ // Holds the sequence of initializers for the global. |
+ SmallVector<Constant *, 10> Initializers; |
+ |
+ // Keeps track of how many initializers are expected for |
+ // the global variable being built. |
+ unsigned InitializersNeeded; |
+ |
+ // The alignment assumed for the global variable being built. |
+ unsigned Alignment; |
+ |
+ // True if the global variable being built is a constant. |
+ bool IsConstant; |
+ |
+ // The index of the next global variable. |
+ unsigned NextGlobalID; |
+ |
+ virtual void ExitBlock() LLVM_OVERRIDE { |
+ verifyNoMissingInitializers(); |
+ unsigned NumIDs = Context->getNumGlobalValueIDs(); |
+ if (NextGlobalID < NumIDs) { |
+ unsigned NumFcnIDs = Context->getNumFunctionIDs(); |
+ std::string Buffer; |
+ raw_string_ostream StrBuf(Buffer); |
+ StrBuf << "Globals block expects " << (NumIDs - NumFcnIDs) |
+ << " global definitions. Found: " << (NextGlobalID - NumFcnIDs); |
+ Error(StrBuf.str()); |
+ } |
+ BlockParserBaseClass::ExitBlock(); |
+ } |
+ |
+ virtual void ProcessRecord() LLVM_OVERRIDE; |
+ |
+ // Checks if the number of initializers needed is the same as the |
+ // number found in the bitcode file. If different, and error message |
+ // is generated, and the internal state of the parser is fixed so |
+ // this condition is no longer violated. |
+ void verifyNoMissingInitializers() { |
+ if (InitializersNeeded != Initializers.size()) { |
+ std::string Buffer; |
+ raw_string_ostream StrBuf(Buffer); |
+ StrBuf << "Global variable @g" |
+ << (NextGlobalID - Context->getNumFunctionIDs()) << " expected " |
+ << InitializersNeeded << " initializer"; |
+ if (InitializersNeeded > 1) |
+ StrBuf << "s"; |
+ StrBuf << ". Found: " << Initializers.size(); |
+ Error(StrBuf.str()); |
+ // Fix up state so that we can continue. |
+ InitializersNeeded = Initializers.size(); |
+ installGlobalVar(); |
+ } |
+ } |
+ |
+ // Reserves a slot in the list of initializers being built. If there |
+ // isn't room for the slot, an error message is generated. |
+ void reserveInitializer(const char *RecordName) { |
+ if (InitializersNeeded <= Initializers.size()) { |
+ Error(std::string(RecordName) + |
+ " record: Too many initializers, ignoring."); |
+ } |
+ } |
+ |
+ // Takes the initializers (and other parser state values) and |
+ // installs a global variable (with the initializers) into the list |
+ // of ValueIDs. |
+ void installGlobalVar() { |
+ Constant *Init = NULL; |
+ switch (Initializers.size()) { |
+ case 0: |
+ Error("No initializer for global variable in global vars block"); |
+ return; |
+ case 1: |
+ Init = Initializers[0]; |
+ break; |
+ default: |
+ Init = ConstantStruct::getAnon(Context->getLLVMContext(), Initializers, |
+ true); |
+ break; |
+ } |
+ GlobalVariable *GV = |
+ new GlobalVariable(*Context->getModule(), Init->getType(), IsConstant, |
+ GlobalValue::InternalLinkage, Init, ""); |
+ GV->setAlignment(Alignment); |
+ if (!Context->assignGlobalVariable(GV, NextGlobalID)) { |
+ std::string Buffer; |
+ raw_string_ostream StrBuf(Buffer); |
+ StrBuf << "Defining global V[" << NextGlobalID |
+ << "] not allowed. Out of range."; |
+ Error(StrBuf.str()); |
+ } |
+ ++NextGlobalID; |
+ Initializers.clear(); |
+ InitializersNeeded = 0; |
+ Alignment = 1; |
+ IsConstant = false; |
+ } |
+}; |
+ |
+void GlobalsParser::ProcessRecord() { |
+ const NaClBitcodeRecord::RecordVector &Values = Record.GetValues(); |
+ switch (Record.GetCode()) { |
+ case naclbitc::GLOBALVAR_COUNT: |
+ // COUNT: [n] |
+ if (checkRecordSize(1, "Globals count")) |
+ return; |
+ if (NextGlobalID != Context->getNumFunctionIDs()) { |
+ Error("Globals count record not first in block."); |
+ return; |
+ } |
+ verifyNoMissingInitializers(); |
+ Context->resizeValueIDsForGlobalVarCount(Values[0]); |
+ return; |
+ case naclbitc::GLOBALVAR_VAR: { |
+ // VAR: [align, isconst] |
+ if (checkRecordSize(2, "Globals variable")) |
+ return; |
+ verifyNoMissingInitializers(); |
+ InitializersNeeded = 1; |
+ Initializers.clear(); |
+ Alignment = (1 << Values[0]) >> 1; |
+ IsConstant = Values[1] != 0; |
+ return; |
+ } |
+ case naclbitc::GLOBALVAR_COMPOUND: |
+ // COMPOUND: [size] |
+ if (checkRecordSize(1, "globals compound")) |
+ return; |
+ if (Initializers.size() > 0 || InitializersNeeded != 1) { |
+ Error("Globals compound record not first initializer"); |
+ return; |
+ } |
+ if (Values[0] < 2) { |
+ std::string Buffer; |
+ raw_string_ostream StrBuf(Buffer); |
+ StrBuf << "Globals compound record size invalid. Found: " << Values[0]; |
+ Error(StrBuf.str()); |
+ return; |
+ } |
+ InitializersNeeded = Values[0]; |
+ return; |
+ case naclbitc::GLOBALVAR_ZEROFILL: { |
+ // ZEROFILL: [size] |
+ if (checkRecordSize(1, "Globals zerofill")) |
+ return; |
+ reserveInitializer("Globals zerofill"); |
+ Type *Ty = |
+ ArrayType::get(Type::getInt8Ty(Context->getLLVMContext()), Values[0]); |
+ Constant *Zero = ConstantAggregateZero::get(Ty); |
+ Initializers.push_back(Zero); |
+ break; |
+ } |
+ case naclbitc::GLOBALVAR_DATA: { |
+ // DATA: [b0, b1, ...] |
+ if (checkRecordSizeAtLeast(1, "Globals data")) |
+ return; |
+ reserveInitializer("Globals data"); |
+ unsigned Size = Values.size(); |
+ SmallVector<uint8_t, 32> Buf; |
+ for (unsigned i = 0; i < Size; ++i) |
+ Buf.push_back(static_cast<uint8_t>(Values[i])); |
+ Constant *Init = ConstantDataArray::get( |
+ Context->getLLVMContext(), ArrayRef<uint8_t>(Buf.data(), Buf.size())); |
+ Initializers.push_back(Init); |
+ break; |
+ } |
+ case naclbitc::GLOBALVAR_RELOC: { |
+ // RELOC: [val, [addend]] |
+ if (checkRecordSizeInRange(1, 2, "Globals reloc")) |
+ return; |
+ Constant *BaseVal = Context->getOrCreateGlobalVarRef(Values[0]); |
+ if (BaseVal == 0) { |
+ std::string Buffer; |
+ raw_string_ostream StrBuf(Buffer); |
+ StrBuf << "Can't find global relocation value: " << Values[0]; |
+ Error(StrBuf.str()); |
+ return; |
+ } |
+ Type *IntPtrType = IntegerType::get(Context->getLLVMContext(), 32); |
+ Constant *Val = ConstantExpr::getPtrToInt(BaseVal, IntPtrType); |
+ if (Values.size() == 2) { |
+ Val = ConstantExpr::getAdd(Val, ConstantInt::get(IntPtrType, Values[1])); |
+ } |
+ Initializers.push_back(Val); |
+ break; |
+ } |
+ default: |
+ BlockParserBaseClass::ProcessRecord(); |
+ return; |
+ } |
+ // If reached, just processed another initializer. See if time |
+ // to install global. |
+ if (InitializersNeeded == Initializers.size()) |
+ installGlobalVar(); |
+} |
+ |
+// Parses a valuesymtab block in the bitcode file. |
+class ValuesymtabParser : public BlockParserBaseClass { |
+ typedef SmallString<128> StringType; |
+ |
+public: |
+ ValuesymtabParser(unsigned BlockID, BlockParserBaseClass *EnclosingParser, |
+ bool AllowBbEntries) |
+ : BlockParserBaseClass(BlockID, EnclosingParser), |
+ AllowBbEntries(AllowBbEntries) {} |
+ |
+ virtual ~ValuesymtabParser() LLVM_OVERRIDE {} |
+ |
+private: |
+ // True if entries to name basic blocks allowed. |
+ bool AllowBbEntries; |
+ |
+ virtual void ProcessRecord() LLVM_OVERRIDE; |
+ |
+ void ConvertToString(StringType &ConvertedName) { |
+ const NaClBitcodeRecord::RecordVector &Values = Record.GetValues(); |
+ for (size_t i = 1, e = Values.size(); i != e; ++i) { |
+ ConvertedName += static_cast<char>(Values[i]); |
+ } |
+ } |
+}; |
+ |
+void ValuesymtabParser::ProcessRecord() { |
+ const NaClBitcodeRecord::RecordVector &Values = Record.GetValues(); |
+ StringType ConvertedName; |
+ switch (Record.GetCode()) { |
+ case naclbitc::VST_CODE_ENTRY: { |
+ // VST_ENTRY: [ValueId, namechar x N] |
+ if (checkRecordSizeAtLeast(2, "Valuesymtab value entry")) |
+ return; |
+ ConvertToString(ConvertedName); |
+ Value *V = Context->getGlobalValueByID(Values[0]); |
+ if (V == 0) { |
+ std::string Buffer; |
+ raw_string_ostream StrBuf(Buffer); |
+ StrBuf << "Invalid global address ID in valuesymtab: " << Values[0]; |
+ Error(StrBuf.str()); |
+ return; |
+ } |
+ V->setName(StringRef(ConvertedName.data(), ConvertedName.size())); |
+ return; |
+ } |
+ case naclbitc::VST_CODE_BBENTRY: { |
+ // VST_BBENTRY: [BbId, namechar x N] |
+ // For now, since we aren't processing function blocks, don't handle. |
+ if (AllowBbEntries) { |
+ Error("Valuesymtab bb entry not implemented"); |
+ return; |
+ } |
+ break; |
+ } |
+ default: |
+ break; |
+ } |
+ // If reached, don't know how to handle record. |
+ BlockParserBaseClass::ProcessRecord(); |
+ return; |
+} |
+ |
+/// Parses the module block in the bitcode file. |
+class ModuleParser : public BlockParserBaseClass { |
+public: |
+ ModuleParser(unsigned BlockID, TopLevelParser *Context) |
+ : BlockParserBaseClass(BlockID, Context) {} |
+ |
+ virtual ~ModuleParser() LLVM_OVERRIDE {} |
+ |
+protected: |
+ virtual bool ParseBlock(unsigned BlockID) LLVM_OVERRIDE; |
+ |
+ virtual void ProcessRecord() LLVM_OVERRIDE; |
+}; |
+ |
+bool ModuleParser::ParseBlock(unsigned BlockID) LLVM_OVERRIDE { |
+ switch (BlockID) { |
+ case naclbitc::BLOCKINFO_BLOCK_ID: |
+ return NaClBitcodeParser::ParseBlock(BlockID); |
+ case naclbitc::TYPE_BLOCK_ID_NEW: { |
+ TypesParser Parser(BlockID, this); |
+ return Parser.ParseThisBlock(); |
+ } |
+ case naclbitc::GLOBALVAR_BLOCK_ID: { |
+ GlobalsParser Parser(BlockID, this); |
+ return Parser.ParseThisBlock(); |
+ } |
+ case naclbitc::VALUE_SYMTAB_BLOCK_ID: { |
+ ValuesymtabParser Parser(BlockID, this, false); |
+ return Parser.ParseThisBlock(); |
+ } |
+ case naclbitc::FUNCTION_BLOCK_ID: { |
+ Error("Function block parser not yet implemented, skipping"); |
+ SkipBlock(); |
+ return false; |
+ } |
+ default: |
+ return BlockParserBaseClass::ParseBlock(BlockID); |
+ } |
+} |
+ |
+void ModuleParser::ProcessRecord() { |
+ const NaClBitcodeRecord::RecordVector &Values = Record.GetValues(); |
+ switch (Record.GetCode()) { |
+ case naclbitc::MODULE_CODE_VERSION: { |
+ // VERSION: [version#] |
+ if (checkRecordSize(1, "Module version")) |
+ return; |
+ unsigned Version = Values[0]; |
+ if (Version != 1) { |
+ std::string Buffer; |
+ raw_string_ostream StrBuf(Buffer); |
+ StrBuf << "Unknown bitstream version: " << Version; |
+ Error(StrBuf.str()); |
+ } |
+ return; |
+ } |
+ case naclbitc::MODULE_CODE_FUNCTION: { |
+ // FUNCTION: [type, callingconv, isproto, linkage] |
+ if (checkRecordSize(4, "Function heading")) |
+ return; |
+ Type *Ty = Context->getTypeByID(Values[0]); |
+ FunctionType *FTy = dyn_cast<FunctionType>(Ty); |
+ if (FTy == 0) { |
+ std::string Buffer; |
+ raw_string_ostream StrBuf(Buffer); |
+ StrBuf << "Function heading expects function type. Found: " << Ty; |
+ Error(StrBuf.str()); |
+ return; |
+ } |
+ CallingConv::ID CallingConv; |
+ if (!naclbitc::DecodeCallingConv(Values[1], CallingConv)) { |
+ std::string Buffer; |
+ raw_string_ostream StrBuf(Buffer); |
+ StrBuf << "Function heading has unknown calling convention: " |
+ << Values[1]; |
+ Error(StrBuf.str()); |
+ return; |
+ } |
+ GlobalValue::LinkageTypes Linkage; |
+ if (!naclbitc::DecodeLinkage(Values[3], Linkage)) { |
+ std::string Buffer; |
+ raw_string_ostream StrBuf(Buffer); |
+ StrBuf << "Function heading has unknown linkage. Found " << Values[3]; |
+ Error(StrBuf.str()); |
+ return; |
+ } |
+ Function *Func = Function::Create(FTy, Linkage, "", Context->getModule()); |
+ Func->setCallingConv(CallingConv); |
+ if (Values[2] == 0) |
+ Context->setNextValueIDAsImplementedFunction(); |
+ Context->setNextFunctionID(Func); |
+ // TODO(kschimpf) verify if Func matches PNaCl ABI. |
+ return; |
+ } |
+ default: |
+ BlockParserBaseClass::ProcessRecord(); |
+ return; |
+ } |
+} |
+ |
+bool TopLevelParser::ParseBlock(unsigned BlockID) { |
+ if (BlockID == naclbitc::MODULE_BLOCK_ID) { |
+ ModuleParser Parser(BlockID, this); |
+ bool ReturnValue = Parser.ParseThisBlock(); |
+ // TODO(kschimpf): Remove once translating function blocks. |
+ errs() << "Global addresses:\n"; |
+ for (size_t i = 0; i < ValueIDValues.size(); ++i) { |
+ errs() << "[" << i << "]: " << *ValueIDValues[i] << "\n"; |
+ } |
+ return ReturnValue; |
+ } |
+ // Generate error message by using default block implementation. |
+ BlockParserBaseClass Parser(BlockID, this); |
+ return Parser.ParseThisBlock(); |
+} |
+ |
+} // end of anonymous namespace. |
+ |
+namespace Ice { |
+ |
+void PNaClTranslator::translate(const std::string &IRFilename) { |
+ OwningPtr<MemoryBuffer> MemBuf; |
+ if (error_code ec = |
+ MemoryBuffer::getFileOrSTDIN(IRFilename.c_str(), MemBuf)) { |
+ errs() << "Error reading '" << IRFilename << "': " << ec.message() << "\n"; |
+ ExitStatus = 1; |
+ return; |
+ } |
+ |
+ if (MemBuf->getBufferSize() % 4 != 0) { |
+ errs() << IRFilename |
+ << ": Bitcode stream should be a multiple of 4 bytes in length.\n"; |
+ ExitStatus = 1; |
+ return; |
+ } |
+ |
+ const unsigned char *BufPtr = (const unsigned char *)MemBuf->getBufferStart(); |
+ const unsigned char *EndBufPtr = BufPtr + MemBuf->getBufferSize(); |
+ |
+ // Read header and verify it is good. |
+ NaClBitcodeHeader Header; |
+ if (Header.Read(BufPtr, EndBufPtr) || !Header.IsSupported()) { |
+ errs() << "Invalid PNaCl bitcode header.\n"; |
+ ExitStatus = 1; |
+ return; |
+ } |
+ |
+ // Create a bitstream reader to read the bitcode file. |
+ NaClBitstreamReader InputStreamFile(BufPtr, EndBufPtr); |
+ NaClBitstreamCursor InputStream(InputStreamFile); |
+ |
+ TopLevelParser Parser(MemBuf->getBufferIdentifier(), Header, InputStream, |
+ ExitStatus); |
wala
2014/07/08 00:56:06
I get a compiler error on this line.
Apparent cau
|
+ int TopLevelBlocks = 0; |
+ while (!InputStream.AtEndOfStream()) { |
+ if (Parser.Parse()) { |
+ ExitStatus = 1; |
+ return; |
+ } |
+ ++TopLevelBlocks; |
+ } |
+ |
+ if (TopLevelBlocks != 1) { |
+ errs() << IRFilename |
+ << ": Contains more than one module. Found: " << TopLevelBlocks |
+ << "\n"; |
+ ExitStatus = 1; |
+ } |
+ return; |
+} |
+ |
+} // end of anonymous namespace. |