Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1)

Unified Diff: src/PNaClTranslator.cpp

Issue 624663002: Introduce model of global initializers in Subzero. (Closed) Base URL: https://chromium.googlesource.com/native_client/pnacl-subzero.git@master
Patch Set: Fix nits. Created 6 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « src/IceTypeConverter.cpp ('k') | src/llvm2ice.cpp » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: src/PNaClTranslator.cpp
diff --git a/src/PNaClTranslator.cpp b/src/PNaClTranslator.cpp
index af78e2f3e802e3f29af026d6a9f3aa69d2762c20..e20faf29bbaa13a92fcf18d8164e4502ec7134b7 100644
--- a/src/PNaClTranslator.cpp
+++ b/src/PNaClTranslator.cpp
@@ -12,10 +12,6 @@
//
//===----------------------------------------------------------------------===//
-#include <cassert>
-#include <memory>
-#include <vector>
-
#include "llvm/Analysis/NaCl/PNaClABIProps.h"
#include "llvm/Bitcode/NaCl/NaClBitcodeDecoders.h"
#include "llvm/Bitcode/NaCl/NaClBitcodeHeader.h"
@@ -34,6 +30,7 @@
#include "IceCfgNode.h"
#include "IceClFlags.h"
#include "IceDefs.h"
+#include "IceGlobalInits.h"
#include "IceInst.h"
#include "IceOperand.h"
#include "IceTypeConverter.h"
@@ -62,13 +59,12 @@ public:
Mod(new Module(InputName, getGlobalContext())), DL(PNaClDataLayout),
Header(Header), TypeConverter(getLLVMContext()),
ErrorStatus(ErrorStatus), NumErrors(0), NumFunctionIds(0),
- NumFunctionBlocks(0),
- GlobalVarPlaceHolderType(convertToLLVMType(Ice::IceType_i8)) {
+ NumFunctionBlocks(0) {
Mod->setDataLayout(PNaClDataLayout);
setErrStream(Translator.getContext()->getStrDump());
}
- ~TopLevelParser() override {}
+ ~TopLevelParser() override { DeleteContainerPointers(GlobalIDAddresses); }
Ice::Translator &getTranslator() { return Translator; }
@@ -103,8 +99,8 @@ public:
/// 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;
+ // to the specified size, and fills elements with nullptr.
+ Type *Ty = ID < TypeIDValues.size() ? TypeIDValues[ID] : nullptr;
if (Ty)
return Ty;
return reportTypeIDAsUndefined(ID);
@@ -112,7 +108,7 @@ public:
/// Defines type for ID.
void setTypeID(unsigned ID, Type *Ty) {
- if (ID < TypeIDValues.size() && TypeIDValues[ID] == NULL) {
+ if (ID < TypeIDValues.size() && TypeIDValues[ID] == nullptr) {
TypeIDValues[ID] = Ty;
return;
}
@@ -122,13 +118,13 @@ public:
/// Sets the next function ID to the given LLVM function.
void setNextFunctionID(Function *Fcn) {
++NumFunctionIds;
- ValueIDValues.push_back(Fcn);
+ FunctionIDValues.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());
+ DefiningFunctionsList.push_back(FunctionIDValues.size());
}
/// Returns the value id that should be associated with the the
@@ -142,28 +138,48 @@ public:
}
/// Returns the LLVM IR value associatd with the global value ID.
- Value *getGlobalValueByID(unsigned ID) const {
- if (ID >= ValueIDValues.size())
- return NULL;
- return ValueIDValues[ID];
+ Function *getFunctionByID(unsigned ID) const {
+ if (ID >= FunctionIDValues.size())
+ return nullptr;
+ Value *V = FunctionIDValues[ID];
+ return cast<Function>(V);
}
/// Returns the corresponding constant associated with a global value
/// (i.e. relocatable).
Ice::Constant *getOrCreateGlobalConstantByID(unsigned ID) {
// TODO(kschimpf): Can this be built when creating global initializers?
+ Ice::Constant *C;
if (ID >= ValueIDConstants.size()) {
- if (ID >= ValueIDValues.size())
- return NULL;
- ValueIDConstants.resize(ValueIDValues.size());
+ C = nullptr;
+ unsigned ExpectedSize =
+ FunctionIDValues.size() + GlobalIDAddresses.size();
+ if (ID >= ExpectedSize)
+ ExpectedSize = ID;
+ ValueIDConstants.resize(ExpectedSize);
+ } else {
+ C = ValueIDConstants[ID];
}
- Ice::Constant *C = ValueIDConstants[ID];
- if (C != NULL)
+ if (C != nullptr)
return C;
- Value *V = ValueIDValues[ID];
- assert(isa<GlobalValue>(V));
- C = getTranslator().getContext()->getConstantSym(getIcePointerType(), 0,
- V->getName());
+
+ // If reached, no such constant exists, create one.
+ std::string Name;
+ unsigned FcnIDSize = FunctionIDValues.size();
+ if (ID < FcnIDSize) {
+ Name = FunctionIDValues[ID]->getName();
+ } else if ((ID - FcnIDSize) < GlobalIDAddresses.size()) {
+ Name = GlobalIDAddresses[ID - FcnIDSize]->getName();
+ } else {
+ std::string Buffer;
+ raw_string_ostream StrBuf(Buffer);
+ StrBuf << "Reference to global not defined: " << ID;
+ Error(StrBuf.str());
+ Name = "??";
+ }
+ const uint64_t Offset = 0;
+ C = getTranslator().getContext()->getConstantSym(
+ getIcePointerType(), Offset, Name);
ValueIDConstants[ID] = C;
return C;
}
@@ -172,51 +188,43 @@ public:
/// 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 NULL;
- 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;
+ /// Returns the number of global IDs (function and global addresses)
+ /// defined in the bitcode file.
+ unsigned getNumGlobalIDs() const {
+ return FunctionIDValues.size() + GlobalIDAddresses.size();
}
- /// 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 == NULL) {
- ValueIDValues[ID] = GV;
- return true;
+ /// Creates Count global addresses.
+ void CreateGlobalAddresses(size_t Count) {
+ assert(GlobalIDAddresses.empty());
+ for (size_t i = 0; i < Count; ++i) {
+ GlobalIDAddresses.push_back(new Ice::GlobalAddress());
}
+ }
- // 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;
+ /// Returns the number of global addresses (i.e. ID's) defined in
+ /// the bitcode file.
+ Ice::SizeT getNumGlobalAddresses() const { return GlobalIDAddresses.size(); }
+
+ /// Returns the global address with the given index.
+ Ice::GlobalAddress *getGlobalAddress(size_t Index) {
+ if (Index < GlobalIDAddresses.size())
+ return GlobalIDAddresses[Index];
+ std::string Buffer;
+ raw_string_ostream StrBuf(Buffer);
+ StrBuf << "Global index " << Index
+ << " not allowed. Out of range. Must be less than "
+ << GlobalIDAddresses.size();
+ Error(StrBuf.str());
+ // TODO(kschimpf) Remove error recovery once implementation complete.
+ if (!GlobalIDAddresses.empty())
+ return GlobalIDAddresses[0];
+ report_fatal_error("Unable to continue");
+ }
+
+ /// Returns the list of read global addresses.
+ const Ice::Translator::GlobalAddressList &getGlobalIDAddresses() {
+ return GlobalIDAddresses;
}
/// Returns the corresponding ICE type for LLVMTy.
@@ -234,13 +242,13 @@ public:
}
/// Returns the LLVM integer type with the given number of Bits. If
- /// Bits is not a valid PNaCl type, returns NULL.
+ /// Bits is not a valid PNaCl type, returns nullptr.
Type *getLLVMIntegerType(unsigned Bits) const {
return TypeConverter.getLLVMIntegerType(Bits);
}
/// Returns the LLVM vector with the given Size and Ty. If not a
- /// valid PNaCl vector type, returns NULL.
+ /// valid PNaCl vector type, returns nullptr.
Type *getLLVMVectorType(unsigned Size, Ice::Type Ty) const {
return TypeConverter.getLLVMVectorType(Size, Ty);
}
@@ -267,9 +275,12 @@ private:
unsigned NumErrors;
// The types associated with each type ID.
std::vector<Type *> TypeIDValues;
- // The (global) value IDs.
- std::vector<WeakVH> ValueIDValues;
- // Relocatable constants associated with ValueIDValues.
+ // The set of function value IDs.
+ std::vector<WeakVH> FunctionIDValues;
+ // The set of global addresses IDs.
+ Ice::Translator::GlobalAddressList GlobalIDAddresses;
+ // Relocatable constants associated with FunctionIDValues and
+ // GlobalIDAddresses.
std::vector<Ice::Constant *> ValueIDConstants;
// The number of function IDs.
unsigned NumFunctionIds;
@@ -278,9 +289,6 @@ private:
// 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;
bool ParseBlock(unsigned BlockID) override;
@@ -380,7 +388,7 @@ protected:
const NaClBitcodeRecord::RecordVector &Values = Record.GetValues();
if (Values.size() == Size)
return true;
- ReportRecordSizeError(Size, RecordName, NULL);
+ ReportRecordSizeError(Size, RecordName, nullptr);
return false;
}
@@ -418,7 +426,7 @@ protected:
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 NULL)
+ /// record that has incorrect size. ContextMessage (if not nullptr)
/// is appended to "record expects" to describe how ExpectedSize
/// should be interpreted.
void ReportRecordSizeError(unsigned ExpectedSize, const char *RecordName,
@@ -477,7 +485,7 @@ private:
};
void TypesParser::ProcessRecord() {
- Type *Ty = NULL;
+ Type *Ty = nullptr;
const NaClBitcodeRecord::RecordVector &Values = Record.GetValues();
switch (Record.GetCode()) {
case naclbitc::TYPE_CODE_NUMENTRY:
@@ -509,7 +517,7 @@ void TypesParser::ProcessRecord() {
if (!isValidRecordSize(1, "Type integer"))
return;
Ty = Context->getLLVMIntegerType(Values[0]);
- if (Ty == NULL) {
+ if (Ty == nullptr) {
std::string Buffer;
raw_string_ostream StrBuf(Buffer);
StrBuf << "Type integer record with invalid bitsize: " << Values[0];
@@ -526,7 +534,7 @@ void TypesParser::ProcessRecord() {
Type *BaseTy = Context->getTypeByID(Values[1]);
Ty = Context->getLLVMVectorType(Values[0],
Context->convertToIceType(BaseTy));
- if (Ty == NULL) {
+ if (Ty == nullptr) {
std::string Buffer;
raw_string_ostream StrBuf(Buffer);
StrBuf << "Invalid type vector record: <" << Values[0] << " x " << *BaseTy
@@ -552,7 +560,7 @@ void TypesParser::ProcessRecord() {
return;
}
// If Ty not defined, assume error. Use void as filler.
- if (Ty == NULL)
+ if (Ty == nullptr)
Ty = Context->convertToLLVMType(Ice::IceType_void);
Context->setTypeID(NextTypeId++, Ty);
}
@@ -562,38 +570,33 @@ class GlobalsParser : public BlockParserBaseClass {
public:
GlobalsParser(unsigned BlockID, BlockParserBaseClass *EnclosingParser)
: BlockParserBaseClass(BlockID, EnclosingParser), InitializersNeeded(0),
- Alignment(1), IsConstant(false) {
- NextGlobalID = Context->getNumFunctionIDs();
- }
+ NextGlobalID(0), CurrentAddress(&DummyAddress) {}
~GlobalsParser() 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.
+ // 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;
+ // Holds the current global address whose initializer is being defined.
+ Ice::GlobalAddress *CurrentAddress;
+
+ // Dummy global address to guarantee CurrentAddress is always defined
+ // (allowing code to not need to check if CurrentAddress is nullptr).
+ Ice::GlobalAddress DummyAddress;
+
void ExitBlock() override {
verifyNoMissingInitializers();
- unsigned NumIDs = Context->getNumGlobalValueIDs();
+ unsigned NumIDs = Context->getNumGlobalAddresses();
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);
+ StrBuf << "Globals block expects " << NumIDs
+ << " global definitions. Found: " << NextGlobalID;
Error(StrBuf.str());
}
BlockParserBaseClass::ExitBlock();
@@ -601,70 +604,22 @@ private:
void ProcessRecord() 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.
+ // Checks if the number of initializers for the CurrentAddress 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()) {
+ size_t NumInits = CurrentAddress->getInitializers().size();
+ if (InitializersNeeded != NumInits) {
std::string Buffer;
raw_string_ostream StrBuf(Buffer);
- StrBuf << "Global variable @g"
- << (NextGlobalID - Context->getNumFunctionIDs()) << " expected "
+ StrBuf << "Global variable @g" << NextGlobalID << " expected "
<< InitializersNeeded << " initializer";
if (InitializersNeeded > 1)
StrBuf << "s";
- StrBuf << ". Found: " << Initializers.size();
- Error(StrBuf.str());
- // TODO(kschimpf) Remove error recovery once implementation complete.
- // 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.";
+ StrBuf << ". Found: " << NumInits;
Error(StrBuf.str());
}
- ++NextGlobalID;
- Initializers.clear();
- InitializersNeeded = 0;
- Alignment = 1;
- IsConstant = false;
}
};
@@ -675,12 +630,11 @@ void GlobalsParser::ProcessRecord() {
// COUNT: [n]
if (!isValidRecordSize(1, "Globals count"))
return;
- if (NextGlobalID != Context->getNumFunctionIDs()) {
+ if (NextGlobalID != Context->getNumGlobalAddresses()) {
Error("Globals count record not first in block.");
return;
}
- verifyNoMissingInitializers();
- Context->resizeValueIDsForGlobalVarCount(Values[0]);
+ Context->CreateGlobalAddresses(Values[0]);
return;
case naclbitc::GLOBALVAR_VAR: {
// VAR: [align, isconst]
@@ -688,16 +642,17 @@ void GlobalsParser::ProcessRecord() {
return;
verifyNoMissingInitializers();
InitializersNeeded = 1;
- Initializers.clear();
- Alignment = (1 << Values[0]) >> 1;
- IsConstant = Values[1] != 0;
+ CurrentAddress = Context->getGlobalAddress(NextGlobalID);
+ CurrentAddress->setAlignment((1 << Values[0]) >> 1);
+ CurrentAddress->setIsConstant(Values[1] != 0);
+ ++NextGlobalID;
return;
}
case naclbitc::GLOBALVAR_COMPOUND:
// COMPOUND: [size]
if (!isValidRecordSize(1, "globals compound"))
return;
- if (Initializers.size() > 0 || InitializersNeeded != 1) {
+ if (!CurrentAddress->getInitializers().empty()) {
Error("Globals compound record not first initializer");
return;
}
@@ -714,55 +669,44 @@ void GlobalsParser::ProcessRecord() {
// ZEROFILL: [size]
if (!isValidRecordSize(1, "Globals zerofill"))
return;
- reserveInitializer("Globals zerofill");
- Type *Ty =
- ArrayType::get(Context->convertToLLVMType(Ice::IceType_i8), Values[0]);
- Constant *Zero = ConstantAggregateZero::get(Ty);
- Initializers.push_back(Zero);
+ CurrentAddress->addInitializer(
+ new Ice::GlobalAddress::ZeroInitializer(Values[0]));
break;
}
case naclbitc::GLOBALVAR_DATA: {
// DATA: [b0, b1, ...]
if (!isValidRecordSizeAtLeast(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);
+ CurrentAddress->addInitializer(
+ new Ice::GlobalAddress::DataInitializer(Values));
break;
}
case naclbitc::GLOBALVAR_RELOC: {
// RELOC: [val, [addend]]
if (!isValidRecordSizeInRange(1, 2, "Globals reloc"))
return;
- Constant *BaseVal = Context->getOrCreateGlobalVarRef(Values[0]);
- if (BaseVal == NULL) {
- std::string Buffer;
- raw_string_ostream StrBuf(Buffer);
- StrBuf << "Can't find global relocation value: " << Values[0];
- Error(StrBuf.str());
- return;
- }
- Type *IntPtrType = Context->convertToLLVMType(Context->getIcePointerType());
- Constant *Val = ConstantExpr::getPtrToInt(BaseVal, IntPtrType);
- if (Values.size() == 2) {
- Val = ConstantExpr::getAdd(Val, ConstantInt::get(IntPtrType, Values[1]));
+ unsigned Index = Values[0];
+ Ice::SizeT Offset = 0;
+ if (Values.size() == 2)
+ Offset = Values[1];
+ unsigned NumFunctions = Context->getNumFunctionIDs();
+ if (Index < NumFunctions) {
+ llvm::Function *Fcn = Context->getFunctionByID(Index);
+ Ice::GlobalAddress::RelocationAddress Addr(Fcn);
+ CurrentAddress->addInitializer(
+ new Ice::GlobalAddress::RelocInitializer(Addr, Offset));
+ } else {
+ Ice::GlobalAddress::RelocationAddress Addr(
+ Context->getGlobalAddress(Index - NumFunctions));
+ CurrentAddress->addInitializer(
+ new Ice::GlobalAddress::RelocInitializer(Addr, Offset));
}
- 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();
}
/// Base class for parsing a valuesymtab block in the bitcode file.
@@ -838,9 +782,9 @@ public:
: BlockParserBaseClass(BlockID, EnclosingParser),
Func(new Ice::Cfg(getTranslator().getContext())), CurrentBbIndex(0),
FcnId(Context->getNextFunctionBlockValueID()),
- LLVMFunc(cast<Function>(Context->getGlobalValueByID(FcnId))),
- CachedNumGlobalValueIDs(Context->getNumGlobalValueIDs()),
- NextLocalInstIndex(Context->getNumGlobalValueIDs()),
+ LLVMFunc(Context->getFunctionByID(FcnId)),
+ CachedNumGlobalValueIDs(Context->getNumGlobalIDs()),
+ NextLocalInstIndex(Context->getNumGlobalIDs()),
InstIsTerminating(false) {
Func->setFunctionName(LLVMFunc->getName());
Func->setReturnType(Context->convertToIceType(LLVMFunc->getReturnType()));
@@ -956,7 +900,7 @@ private:
uint32_t LocalIndex = NextLocalInstIndex - CachedNumGlobalValueIDs;
if (LocalIndex < LocalOperands.size()) {
Ice::Operand *Op = LocalOperands[LocalIndex];
- if (Op != NULL) {
+ if (Op != nullptr) {
if (Ice::Variable *Var = dyn_cast<Ice::Variable>(Op)) {
if (Var->getType() == Ty) {
++NextLocalInstIndex;
@@ -1007,7 +951,7 @@ private:
report_fatal_error("Unable to continue");
}
Ice::Operand *Op = LocalOperands[LocalIndex];
- if (Op == NULL) {
+ if (Op == nullptr) {
std::string Buffer;
raw_string_ostream StrBuf(Buffer);
StrBuf << "Value index " << Index << " not defined!";
@@ -1033,7 +977,7 @@ private:
// If element not defined, set it.
Ice::Operand *OldOp = LocalOperands[LocalIndex];
- if (OldOp == NULL) {
+ if (OldOp == nullptr) {
LocalOperands[LocalIndex] = Op;
return;
}
@@ -1678,7 +1622,7 @@ void FunctionParser::ProcessRecord() {
if (Values.size() == 1) {
// BR: [bb#]
Ice::CfgNode *Block = getBranchBasicBlock(Values[0]);
- if (Block == NULL)
+ if (Block == nullptr)
return;
CurrentNode->appendInst(Ice::InstBr::create(Func, Block));
} else {
@@ -1696,7 +1640,7 @@ void FunctionParser::ProcessRecord() {
}
Ice::CfgNode *ThenBlock = getBranchBasicBlock(Values[0]);
Ice::CfgNode *ElseBlock = getBranchBasicBlock(Values[1]);
- if (ThenBlock == NULL || ElseBlock == NULL)
+ if (ThenBlock == nullptr || ElseBlock == nullptr)
return;
CurrentNode->appendInst(
Ice::InstBr::create(Func, Cond, ThenBlock, ElseBlock));
@@ -1897,11 +1841,10 @@ void FunctionParser::ProcessRecord() {
uint32_t CalleeIndex = convertRelativeToAbsIndex(Values[1], BaseIndex);
Ice::Operand *Callee = getOperand(CalleeIndex);
Ice::Type ReturnType = Ice::IceType_void;
- const Ice::Intrinsics::FullIntrinsicInfo *IntrinsicInfo = NULL;
+ const Ice::Intrinsics::FullIntrinsicInfo *IntrinsicInfo = nullptr;
if (Record.GetCode() == naclbitc::FUNC_CODE_INST_CALL) {
- Function *Fcn =
- dyn_cast<Function>(Context->getGlobalValueByID(CalleeIndex));
- if (Fcn == NULL) {
+ Function *Fcn = Context->getFunctionByID(CalleeIndex);
+ if (Fcn == nullptr) {
std::string Buffer;
raw_string_ostream StrBuf(Buffer);
StrBuf << "Function call to non-function: " << *Callee;
@@ -1932,10 +1875,11 @@ void FunctionParser::ProcessRecord() {
}
// Create the call instruction.
- Ice::Variable *Dest =
- (ReturnType == Ice::IceType_void) ? NULL : getNextInstVar(ReturnType);
+ Ice::Variable *Dest = (ReturnType == Ice::IceType_void)
+ ? nullptr
+ : getNextInstVar(ReturnType);
Ice::SizeT NumParams = Values.size() - ParamsStartIndex;
- Ice::InstCall *Inst = NULL;
+ Ice::InstCall *Inst = nullptr;
if (IntrinsicInfo) {
Inst =
Ice::InstIntrinsicCall::create(Func, NumParams, Dest, Callee,
@@ -2215,15 +2159,29 @@ private:
// and generated global constant initializers.
bool GlobalAddressNamesAndInitializersInstalled;
- // Temporary hack to generate names for unnamed global addresses,
- // and generate global constant initializers. May be called multiple
+ // Generates names for unnamed global addresses, and lowers global
+ // constant initializers to the target. May be called multiple
// times. Only the first call will do the installation.
- // NOTE: Doesn't handle relocations for global constant initializers.
void InstallGlobalAddressNamesAndInitializers() {
if (!GlobalAddressNamesAndInitializersInstalled) {
- getTranslator().nameUnnamedGlobalAddresses(Context->getModule());
+ Ice::Translator &Trans = getTranslator();
+ const Ice::IceString &GlobalPrefix = getFlags().DefaultGlobalPrefix;
+ if (!GlobalPrefix.empty()) {
+ uint32_t NameIndex = 0;
+ for (Ice::GlobalAddress *Address : Context->getGlobalIDAddresses()) {
+ if (!Address->hasName()) {
+ Address->setName(Trans.createUnnamedName(GlobalPrefix, NameIndex));
+ ++NameIndex;
+ } else {
+ Trans.checkIfUnnamedNameSafe(Address->getName(), "global",
+ GlobalPrefix,
+ Trans.getContext()->getStrDump());
+ }
+ }
+ }
+ Trans.nameUnnamedFunctions(Context->getModule());
if (!getFlags().DisableGlobals)
- getTranslator().convertGlobals(Context->getModule());
+ getTranslator().lowerGlobals(Context->getGlobalIDAddresses());
GlobalAddressNamesAndInitializersInstalled = true;
}
}
@@ -2254,15 +2212,26 @@ private:
};
void ModuleValuesymtabParser::setValueName(uint64_t Index, StringType &Name) {
- Value *V = Context->getGlobalValueByID(Index);
- if (V == NULL) {
- std::string Buffer;
- raw_string_ostream StrBuf(Buffer);
- StrBuf << "Invalid global address ID in valuesymtab: " << Index;
- Error(StrBuf.str());
+ if (Index < Context->getNumFunctionIDs()) {
+ Function *Fcn = Context->getFunctionByID(Index);
+ if (Fcn != nullptr) {
+ Fcn->setName(StringRef(Name.data(), Name.size()));
+ return;
+ }
+ } else {
+ unsigned NumFunctions = Context->getNumFunctionIDs();
+ if (Index >= NumFunctions) {
+ Context->getGlobalAddress(Index - NumFunctions)
+ ->setName(StringRef(Name.data(), Name.size()));
+ }
return;
}
- V->setName(StringRef(Name.data(), Name.size()));
+
+ std::string Buffer;
+ raw_string_ostream StrBuf(Buffer);
+ StrBuf << "Invalid global address ID in valuesymtab: " << Index;
+ Error(StrBuf.str());
+ return;
}
void ModuleValuesymtabParser::setBbName(uint64_t Index, StringType &Name) {
@@ -2321,7 +2290,7 @@ void ModuleParser::ProcessRecord() {
return;
Type *Ty = Context->getTypeByID(Values[0]);
FunctionType *FTy = dyn_cast<FunctionType>(Ty);
- if (FTy == NULL) {
+ if (FTy == nullptr) {
std::string Buffer;
raw_string_ostream StrBuf(Buffer);
StrBuf << "Function heading expects function type. Found: " << Ty;
« no previous file with comments | « src/IceTypeConverter.cpp ('k') | src/llvm2ice.cpp » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698