Introduce model of global initializers in Subzero.

src/PNaClTranslator.cpp

 //===- 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 <cassert>
-#include <memory>
-#include <vector>
-
 #include "llvm/Analysis/NaCl/PNaClABIProps.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/DataLayout.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 "IceCfg.h"
 #include "IceCfgNode.h"
 #include "IceClFlags.h"
 #include "IceDefs.h"
+#include "IceGlobalInits.h"
 #include "IceInst.h"
 #include "IceOperand.h"
 #include "IceTypeConverter.h"
 #include "PNaClTranslator.h"
 
 using namespace llvm;
 
 namespace {
 
 // TODO(kschimpf) Remove error recovery once implementation complete.
 static cl::opt<bool> AllowErrorRecovery(
     "allow-pnacl-reader-error-recovery",
     cl::desc("Allow error recovery when reading PNaCl bitcode."),
     cl::init(false));
 
 // Top-level class to read PNaCl bitcode files, and translate to ICE.
 class TopLevelParser : public NaClBitcodeParser {
   TopLevelParser(const TopLevelParser &) = delete;
   TopLevelParser &operator=(const TopLevelParser &) = delete;
 
 public:
   TopLevelParser(Ice::Translator &Translator, const std::string &InputName,
                  NaClBitcodeHeader &Header, NaClBitstreamCursor &Cursor,
                  bool &ErrorStatus)
       : NaClBitcodeParser(Cursor), Translator(Translator),
         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; }
 
   // Generates error with given Message. Always returns true.
   bool Error(const std::string &Message) override {
     ErrorStatus = true;
     ++NumErrors;
     NaClBitcodeParser::Error(Message);
     if (!AllowErrorRecovery)
       report_fatal_error("Unable to continue");
@@ skipping 14 matching lines @@
 
   /// 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;
+    // to the specified size, and fills elements with nullptr.
+    Type *Ty = ID < TypeIDValues.size() ? TypeIDValues[ID] : nullptr;
     if (Ty)
       return Ty;
     return reportTypeIDAsUndefined(ID);
   }
 
   /// 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;
     }
     reportBadSetTypeID(ID, Ty);
   }
 
   /// 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
   /// current function block. Increments internal counters during call
   /// so that it will be in correct position for next function block.
   unsigned getNextFunctionBlockValueID() {
     if (NumFunctionBlocks >= DefiningFunctionsList.size())
       report_fatal_error(
           "More function blocks than defined function addresses");
     return DefiningFunctionsList[NumFunctionBlocks++];
   }
 
   /// 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));
+
+    // 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 = "??";
+    }
     C = getTranslator().getContext()->getConstantSym(getIcePointerType(), 0,

[Jim Stichnoth, 2014/10/06 18:16:38]

replace 0 with a local symbolic constant

[Karl, 2014/10/06 22:44:04]

Done.

-                                                     V->getName());
+                                                     Name);
     ValueIDConstants[ID] = C;
     return C;
   }
 
   /// 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 number of global IDs (function and global addresses)
+  /// defined in the bitcode file.
+  unsigned getNumGlobalIDs() const {
+    return FunctionIDValues.size() + GlobalIDAddresses.size();
   }
 
-  /// 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;
+  /// 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());
+    }
   }
 
-  /// 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;
-    }
+  /// Returns the number of global addresses (i.e. ID's) defined in
+  /// the bitcode file.
+  Ice::SizeT getNumGlobalAddresses() const { return GlobalIDAddresses.size(); }
 
-    // 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 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.
   Ice::Type convertToIceType(Type *LLVMTy) {
     Ice::Type IceTy = TypeConverter.convertToIceType(LLVMTy);
     if (IceTy >= Ice::IceType_NUM) {
       return convertToIceTypeError(LLVMTy);
     }
     return IceTy;
   }
 
   /// Returns the corresponding LLVM type for IceTy.
   Type *convertToLLVMType(Ice::Type IceTy) const {
     return TypeConverter.convertToLLVMType(IceTy);
   }
 
   /// 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);
   }
 
   /// Returns the model for pointer types in ICE.
   Ice::Type getIcePointerType() const {
     return TypeConverter.getIcePointerType();
   }
 
 private:
   // The translator associated with the parser.
   Ice::Translator &Translator;
   // The parsed module.
   std::unique_ptr<Module> Mod;
   // The data layout to use.
   DataLayout DL;
   // The bitcode header.
   NaClBitcodeHeader &Header;
   // Converter between LLVM and ICE types.
   Ice::TypeConverter TypeConverter;
   // The exit status that should be set to true if an error occurs.
   bool &ErrorStatus;
   // 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;
-  // 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;
   // The number of function blocks (processed so far).
   unsigned NumFunctionBlocks;
   // 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;
 
   /// 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);
 
@@ skipping 79 matching lines @@
   // Default implementation. Reports that the record is not
   // understood.
   void ProcessRecord() override;
 
   // Checks if the size of the record is Size.  Return true if valid.
   // Otherwise generates an error and returns false.
   bool isValidRecordSize(unsigned Size, const char *RecordName) {
     const NaClBitcodeRecord::RecordVector &Values = Record.GetValues();
     if (Values.size() == Size)
       return true;
-    ReportRecordSizeError(Size, RecordName, NULL);
+    ReportRecordSizeError(Size, RecordName, nullptr);
     return false;
   }
 
   // Checks if the size of the record is at least as large as the
   // LowerLimit. Returns true if valid.  Otherwise generates an error
   // and returns false.
   bool isValidRecordSizeAtLeast(unsigned LowerLimit, const char *RecordName) {
     const NaClBitcodeRecord::RecordVector &Values = Record.GetValues();
     if (Values.size() >= LowerLimit)
       return true;
@@ skipping 17 matching lines @@
   // valid.  Otherwise generates an error and returns false.
   bool isValidRecordSizeInRange(unsigned LowerLimit, unsigned UpperLimit,
                                 const char *RecordName) {
     return isValidRecordSizeAtLeast(LowerLimit, RecordName) ||
            isValidRecordSizeAtMost(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 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,
                              const char *ContextMessage);
 };
 
 void BlockParserBaseClass::ReportRecordSizeError(unsigned ExpectedSize,
                                                  const char *RecordName,
                                                  const char *ContextMessage) {
   std::string Buffer;
@@ skipping 38 matching lines @@
 
 private:
   // The type ID that will be associated with the next type defining
   // record in the types block.
   unsigned NextTypeId;
 
   void ProcessRecord() override;
 };
 
 void TypesParser::ProcessRecord() {
-  Type *Ty = NULL;
+  Type *Ty = nullptr;
   const NaClBitcodeRecord::RecordVector &Values = Record.GetValues();
   switch (Record.GetCode()) {
   case naclbitc::TYPE_CODE_NUMENTRY:
     // NUMENTRY: [numentries]
     if (!isValidRecordSize(1, "Type count"))
       return;
     Context->resizeTypeIDValues(Values[0]);
     return;
   case naclbitc::TYPE_CODE_VOID:
     // VOID
@@ skipping 11 matching lines @@
     // DOUBLE
     if (!isValidRecordSize(0, "Type double"))
       return;
     Ty = Context->convertToLLVMType(Ice::IceType_f64);
     break;
   case naclbitc::TYPE_CODE_INTEGER:
     // INTEGER: [width]
     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];
       Error(StrBuf.str());
       // TODO(kschimpf) Remove error recovery once implementation complete.
       // Fix type so that we can continue.
       Ty = Context->convertToLLVMType(Ice::IceType_i32);
     }
     break;
   case naclbitc::TYPE_CODE_VECTOR: {
     // VECTOR: [numelts, eltty]
     if (!isValidRecordSize(2, "Type vector"))
       return;
     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
              << ">";
       Error(StrBuf.str());
       Ty = Context->convertToLLVMType(Ice::IceType_void);
     }
     break;
   }
   case naclbitc::TYPE_CODE_FUNCTION: {
     // FUNCTION: [vararg, retty, paramty x N]
     if (!isValidRecordSizeAtLeast(2, "Type signature"))
       return;
     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();
     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);
 }
 
 /// 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();
-  }
+        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();
   }
 
   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;
   }
 };
 
 void GlobalsParser::ProcessRecord() {
   const NaClBitcodeRecord::RecordVector &Values = Record.GetValues();
   switch (Record.GetCode()) {
   case naclbitc::GLOBALVAR_COUNT:
     // 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]
     if (!isValidRecordSize(2, "Globals variable"))
       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;
     }
     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 (!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;
+    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));
     }
-    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]));
-    }
-    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.
 class ValuesymtabParser : public BlockParserBaseClass {
   ValuesymtabParser(const ValuesymtabParser &) = delete;
   void operator=(const ValuesymtabParser &) = delete;
 
 public:
   ValuesymtabParser(unsigned BlockID, BlockParserBaseClass *EnclosingParser)
       : BlockParserBaseClass(BlockID, EnclosingParser) {}
@@ skipping 55 matching lines @@
 class FunctionParser : public BlockParserBaseClass {
   FunctionParser(const FunctionParser &) = delete;
   FunctionParser &operator=(const FunctionParser &) = delete;
   friend class FunctionValuesymtabParser;
 
 public:
   FunctionParser(unsigned BlockID, BlockParserBaseClass *EnclosingParser)
       : 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()));
     Func->setInternal(LLVMFunc->hasInternalLinkage());
     CurrentNode = InstallNextBasicBlock();
     Func->setEntryNode(CurrentNode);
     for (auto ArgI = LLVMFunc->arg_begin(), ArgE = LLVMFunc->arg_end();
          ArgI != ArgE; ++ArgI) {
       Func->addArg(getNextInstVar(Context->convertToIceType(ArgI->getType())));
     }
@@ skipping 95 matching lines @@
     return Func->makeVariable(Ty);
   }
 
   // Generates the next available local variable using the given type.
   Ice::Variable *getNextInstVar(Ice::Type Ty) {
     assert(NextLocalInstIndex >= CachedNumGlobalValueIDs);
     // Before creating one, see if a forwardtyperef has already defined it.
     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;
             return Var;
           }
         }
         std::string Buffer;
         raw_string_ostream StrBuf(Buffer);
         StrBuf << "Illegal forward referenced instruction ("
                << NextLocalInstIndex << "): " << *Op;
@@ skipping 30 matching lines @@
     }
     uint32_t LocalIndex = Index - CachedNumGlobalValueIDs;
     if (LocalIndex >= LocalOperands.size()) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Value index " << Index << " not defined!";
       Error(StrBuf.str());
       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!";
       Error(StrBuf.str());
       report_fatal_error("Unable to continue");
     }
     return Op;
   }
 
   // Sets element Index (in the local operands list) to Op.
   void setOperand(uint32_t Index, Ice::Operand *Op) {
     assert(Op);
     // Check if simple push works.
     uint32_t LocalIndex = Index - CachedNumGlobalValueIDs;
     if (LocalIndex == LocalOperands.size()) {
       LocalOperands.push_back(Op);
       return;
     }
 
     // Must be forward reference, expand vector to accommodate.
     if (LocalIndex >= LocalOperands.size())
       LocalOperands.resize(LocalIndex + 1);
 
     // If element not defined, set it.
     Ice::Operand *OldOp = LocalOperands[LocalIndex];
-    if (OldOp == NULL) {
+    if (OldOp == nullptr) {
       LocalOperands[LocalIndex] = Op;
       return;
     }
 
     // See if forward reference matches.
     if (OldOp == Op)
       return;
 
     // Error has occurred.
     std::string Buffer;
@@ skipping 624 matching lines @@
       CurrentNode->appendInst(
           Ice::InstRet::create(Func, getRelativeOperand(Values[0], BaseIndex)));
     }
     InstIsTerminating = true;
     break;
   }
   case naclbitc::FUNC_CODE_INST_BR: {
     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 {
       // BR: [bb#, bb#, opval]
       if (!isValidRecordSize(3, "function block branch"))
         return;
       Ice::Operand *Cond = getRelativeOperand(Values[2], BaseIndex);
       if (Cond->getType() != Ice::IceType_i1) {
         std::string Buffer;
         raw_string_ostream StrBuf(Buffer);
         StrBuf << "Branch condition " << *Cond << " not i1. Found: "
                << Cond->getType();
         Error(StrBuf.str());
         return;
       }
       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));
     }
     InstIsTerminating = true;
     break;
   }
   case naclbitc::FUNC_CODE_INST_SWITCH: {
     // SWITCH: [Condty, Cond, BbIndex, NumCases Case ...]
     // where Case = [1, 1, Value, BbIndex].
@@ skipping 180 matching lines @@
              << " not understood.";
       Error(StrBuf.str());
       return;
     }
     bool IsTailCall = static_cast<bool>(CCInfo & 1);
 
     // Extract out the called function and its return type.
     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;
         Error(StrBuf.str());
         return;
       }
 
       FunctionType *FcnTy = Fcn->getFunctionType();
       ReturnType = Context->convertToIceType(FcnTy->getReturnType());
 
@@ skipping 10 matching lines @@
           StrBuf << "Invalid PNaCl intrinsic call to " << Name;
           Error(StrBuf.str());
           return;
         }
       }
     } else {
       ReturnType = Context->convertToIceType(Context->getTypeByID(Values[2]));
     }
 
     // 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,
                                          IntrinsicInfo->Info);
     } else {
       Inst = Ice::InstCall::create(Func, NumParams, Dest, Callee, IsTailCall);
     }
 
     // Add parameters.
     for (Ice::SizeT ParamIndex = 0; ParamIndex < NumParams; ++ParamIndex) {
@@ skipping 259 matching lines @@
       : BlockParserBaseClass(BlockID, Context),
         GlobalAddressNamesAndInitializersInstalled(false) {}
 
   ~ModuleParser() override {}
 
 private:
   // True if we have already instaledl names for unnamed global addresses,
   // 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().lowerIceGlobals(Context->getGlobalIDAddresses());
       GlobalAddressNamesAndInitializersInstalled = true;
     }
   }
 
   bool ParseBlock(unsigned BlockID) override;
 
   void ExitBlock() override {
     InstallGlobalAddressNamesAndInitializers();
     getTranslator().emitConstants();
   }
@@ skipping 10 matching lines @@
       : ValuesymtabParser(BlockID, MP) {}
 
   ~ModuleValuesymtabParser() override {}
 
 private:
   void setValueName(uint64_t Index, StringType &Name) override;
   void setBbName(uint64_t Index, StringType &Name) override;
 };
 
 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) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   StrBuf << "Can't define basic block name at global level: '" << Name
          << "' -> " << Index;
   Error(StrBuf.str());
 }
 
@@ skipping 38 matching lines @@
       Error(StrBuf.str());
     }
     return;
   }
   case naclbitc::MODULE_CODE_FUNCTION: {
     // FUNCTION:  [type, callingconv, isproto, linkage]
     if (!isValidRecordSize(4, "Function heading"))
       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;
       Error(StrBuf.str());
       return;
     }
     CallingConv::ID CallingConv;
     if (!naclbitc::DecodeCallingConv(Values[1], CallingConv)) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
@@ skipping 82 matching lines @@
 
   if (TopLevelBlocks != 1) {
     errs() << IRFilename
            << ": Contains more than one module. Found: " << TopLevelBlocks
            << "\n";
     ErrorStatus = true;
   }
 }
 
 } // end of namespace Ice