Introduce the notion of function addresses in Subzero.

crosstest/test_global_main.cpp

@@ -23,6 +23,16 @@ namespace Subzero_ {
 #include "test_global.h"
 }
 
+int ExternName1 = 36363;
+float ExternName2 = 357.05e-10;
+char ExternName3[] = {'a', 'b', 'c'};
+struct {
+  int a;
+  float b;
+  double d;
+} ExternName4 = {-111, 2.69, 55.19};
+double ExternName5 = 3.44e26;
+
 int main(int argc, char **argv) {
   size_t TotalTests = 0;
   size_t Passes = 0;

src/IceConverter.cpp

@@ -34,6 +34,7 @@
 #include "IceTypes.h"
 #include "IceTypeConverter.h"
 
+// TODO(kschimpf): Remove two namespaces being visible at once.
 using namespace llvm;
 
 namespace {
@@ -52,11 +53,14 @@ class LLVM2ICEConverter {
   LLVM2ICEConverter &operator=(const LLVM2ICEConverter &) = delete;
 
 public:
-  LLVM2ICEConverter(Ice::GlobalContext *Ctx, LLVMContext &LLVMContext)
-      : Ctx(Ctx), TypeConverter(LLVMContext) {}
+  LLVM2ICEConverter(Ice::Converter &Converter)
+      : Converter(Converter), Ctx(Converter.getContext()),
+        TypeConverter(Converter.getModule()->getContext()) {}
+
+  Ice::Converter &getConverter() const { return Converter; }
 
 protected:
-  // Data
+  Ice::Converter &Converter;
   Ice::GlobalContext *Ctx;
   const Ice::TypeConverter TypeConverter;
 };
@@ -72,8 +76,8 @@ class LLVM2ICEFunctionConverter : LLVM2ICEConverter {
   operator=(const LLVM2ICEFunctionConverter &) = delete;
 
 public:
-  LLVM2ICEFunctionConverter(Ice::GlobalContext *Ctx, LLVMContext &LLVMContext)
-      : LLVM2ICEConverter(Ctx, LLVMContext), Func(NULL) {}
+  LLVM2ICEFunctionConverter(Ice::Converter &Converter)
+      : LLVM2ICEConverter(Converter), Func(nullptr) {}
 
   // Caller is expected to delete the returned Ice::Cfg object.
   Ice::Cfg *convertFunction(const Function *F) {
@@ -126,12 +130,12 @@ public:
       else if (Type == Ice::IceType_f64)
         return Ctx->getConstantDouble(CFP->getValueAPF().convertToDouble());
       llvm_unreachable("Unexpected floating point type");
-      return NULL;
+      return nullptr;
     } else if (const auto CU = dyn_cast<UndefValue>(Const)) {
       return Ctx->getConstantUndef(convertToIceType(CU->getType()));
     } else {
       llvm_unreachable("Unhandled constant type");
-      return NULL;
+      return nullptr;
     }
   }
 
@@ -141,7 +145,7 @@ private:
   // and a version that just uses convertToIceType on V.
   Ice::Variable *mapValueToIceVar(const Value *V, Ice::Type IceTy) {
     if (IceTy == Ice::IceType_void)
-      return NULL;
+      return nullptr;
     if (VarMap.find(V) == VarMap.end()) {
       VarMap[V] = Func->makeVariable(IceTy, V->getName());
     }
@@ -169,10 +173,10 @@ private:
 
   // Given an LLVM instruction and an operand number, produce the
   // Ice::Operand this refers to. If there's no such operand, return
-  // NULL.
+  // nullptr.
   Ice::Operand *convertOperand(const Instruction *Inst, unsigned OpNum) {
     if (OpNum >= Inst->getNumOperands()) {
-      return NULL;
+      return nullptr;
     }
     const Value *Op = Inst->getOperand(OpNum);
     return convertValue(Op);
@@ -292,7 +296,7 @@ private:
     }
 
     llvm_unreachable("convertInstruction");
-    return NULL;
+    return nullptr;
   }
 
   Ice::Inst *convertLoadInstruction(const LoadInst *Inst) {
@@ -524,8 +528,8 @@ private:
     unsigned NumArgs = Inst->getNumArgOperands();
     // Note: Subzero doesn't (yet) do anything special with the Tail
     // flag in the bitcode, i.e. CallInst::isTailCall().
-    Ice::InstCall *NewInst = NULL;
-    const Ice::Intrinsics::FullIntrinsicInfo *Info = NULL;
+    Ice::InstCall *NewInst = nullptr;
+    const Ice::Intrinsics::FullIntrinsicInfo *Info = nullptr;
 
     if (const auto Target = dyn_cast<Ice::ConstantRelocatable>(CallTarget)) {
       // Check if this direct call is to an Intrinsic (starts with "llvm.")
@@ -545,7 +549,7 @@ private:
     }
 
     // Not an intrinsic call.
-    if (NewInst == NULL) {
+    if (NewInst == nullptr) {
       NewInst = Ice::InstCall::create(Func, NumArgs, Dest, CallTarget,
                                       Inst->isTailCall());
     }
@@ -636,48 +640,37 @@ class LLVM2ICEGlobalsConverter : public LLVM2ICEConverter {
   operator-(const LLVM2ICEGlobalsConverter &) = delete;
 
 public:
-  LLVM2ICEGlobalsConverter(Ice::GlobalContext *Ctx, LLVMContext &LLVMContext)
-      : LLVM2ICEConverter(Ctx, LLVMContext) {}
-
-  ~LLVM2ICEGlobalsConverter() { DeleteContainerSeconds(GlobalVarAddressMap); }
+  LLVM2ICEGlobalsConverter(Ice::Converter &Converter)
+      : LLVM2ICEConverter(Converter) {}
 
-  /// Converts global variables, and their initializers into ICE global
-  /// addresses, for module Mod. Puts corresponding converted global
-  /// addresses into GlobalAddresses.
-  void convertGlobalsToIce(Module *Mod,
-                           Ice::Translator::GlobalAddressList &GlobalAddresses);
+  /// Converts global variables, and their initializers into ICE
+  /// global variable declarations, for module Mod. Puts corresponding
+  /// converted declarations into VariableDeclarations.
+  void convertGlobalsToIce(
+      Module *Mod,
+      Ice::Translator::VariableDeclarationListType &VariableDeclarations);
 
 private:
-  typedef std::map<const GlobalVariable *, Ice::GlobalAddress *>
-      GlobalVarAddressMapType;
-  // Map from global variables to their corresponding global address.
-  GlobalVarAddressMapType GlobalVarAddressMap;
-
-  // Adds the Initializer to the list of initializers for Global address.
-  void addGlobalInitializer(Ice::GlobalAddress &Global,
+  // Adds the Initializer to the list of initializers for the Global
+  // variable declaraation.
+  void addGlobalInitializer(Ice::VariableDeclaration &Global,
                             const Constant *Initializer) {
     const bool HasOffset = false;
-    const Ice::GlobalAddress::RelocOffsetType Offset = 0;
+    const Ice::VariableDeclaration::RelocOffsetType Offset = 0;
     addGlobalInitializer(Global, Initializer, HasOffset, Offset);
   }
 
-  // Adds Initializer to the list of initializers for Global
-  // address. HasOffset is true only if Initializer is a relocation
-  // initializer and Offset should be added to the relocation.
-  void addGlobalInitializer(Ice::GlobalAddress &Global,
+  // Adds Initializer to the list of initializers for Global variable
+  // declaration.  HasOffset is true only if Initializer is a
+  // relocation initializer and Offset should be added to the
+  // relocation.
+  void addGlobalInitializer(Ice::VariableDeclaration &Global,
                             const Constant *Initializer, bool HasOffset,
-                            Ice::GlobalAddress::RelocOffsetType Offset);
-
-  // Returns the global address associated with global variable GV.
-  Ice::GlobalAddress *getGlobalVarAddress(const GlobalVariable *GV) {
-    if (GlobalVarAddressMap.find(GV) == GlobalVarAddressMap.end())
-      GlobalVarAddressMap[GV] = new Ice::GlobalAddress();
-    return GlobalVarAddressMap[GV];
-  }
+                            Ice::VariableDeclaration::RelocOffsetType Offset);
 
   // Converts the given constant C to the corresponding integer
   // literal it contains.
-  Ice::GlobalAddress::RelocOffsetType
+  Ice::VariableDeclaration::RelocOffsetType
   getIntegerLiteralConstant(const Value *C) {
     const auto CI = dyn_cast<ConstantInt>(C);
     if (CI && CI->getType()->isIntegerTy(32))
@@ -692,30 +685,26 @@ private:
 };
 
 void LLVM2ICEGlobalsConverter::convertGlobalsToIce(
-    Module *Mod, Ice::Translator::GlobalAddressList &GlobalAddresses) {
+    Module *Mod,
+    Ice::Translator::VariableDeclarationListType &VariableDeclarations) {
   for (Module::const_global_iterator I = Mod->global_begin(),
                                      E = Mod->global_end();
        I != E; ++I) {
     if (!I->hasInitializer() && Ctx->getFlags().AllowUninitializedGlobals)
       continue;
 
-    const auto GV = dyn_cast<GlobalVariable>(I);
-    assert(GV);
+    const GlobalVariable *GV = I;
     Ice::IceString Name = GV->getName();
     if (!GV->hasInternalLinkage()) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
-      StrBuf << "Can't define external global address: " << Name;
+      StrBuf << "Can't define external global declaration: " << Name;
       report_fatal_error(StrBuf.str());
     }
 
-    Ice::GlobalAddress *Addr = getGlobalVarAddress(GV);
-    GlobalAddresses.push_back(Addr);
-    Addr->setAlignment(GV->getAlignment());
-    Addr->setIsConstant(GV->isConstant());
-    // Note: We allow external for cross tests.
-    Addr->setIsInternal(!GV->isExternallyInitialized());
-    Addr->setName(Name);
+    Ice::GlobalDeclaration *Var = getConverter().getGlobalDeclaration(GV);
+    Ice::VariableDeclaration* VarDecl = cast<Ice::VariableDeclaration>(Var);
+    VariableDeclarations.push_back(VarDecl);
 
     const Constant *Initializer = GV->getInitializer();
     if (const auto CompoundInit = dyn_cast<ConstantStruct>(Initializer)) {
@@ -723,24 +712,25 @@ void LLVM2ICEGlobalsConverter::convertGlobalsToIce(
                                              E = CompoundInit->op_end();
            I != E; ++I) {
         if (const auto Init = dyn_cast<Constant>(I)) {
-          addGlobalInitializer(*Addr, Init);
+          addGlobalInitializer(*VarDecl, Init);
         }
       }
     } else {
-      addGlobalInitializer(*Addr, Initializer);
+      addGlobalInitializer(*VarDecl, Initializer);
     }
   }
 }
 
 void LLVM2ICEGlobalsConverter::addGlobalInitializer(
-    Ice::GlobalAddress &Global, const Constant *Initializer, bool HasOffset,
-    Ice::GlobalAddress::RelocOffsetType Offset) {
+    Ice::VariableDeclaration &Global, const Constant *Initializer,
+    bool HasOffset, Ice::VariableDeclaration::RelocOffsetType Offset) {
+  (void)HasOffset;
   assert(HasOffset || Offset == 0);
 
   if (const auto CDA = dyn_cast<ConstantDataArray>(Initializer)) {
     assert(!HasOffset && isa<IntegerType>(CDA->getElementType()) &&
            (cast<IntegerType>(CDA->getElementType())->getBitWidth() == 8));
-    Global.addInitializer(new Ice::GlobalAddress::DataInitializer(
+    Global.addInitializer(new Ice::VariableDeclaration::DataInitializer(
         CDA->getRawDataValues().data(), CDA->getNumElements()));
     return;
   }
@@ -750,7 +740,7 @@ void LLVM2ICEGlobalsConverter::addGlobalInitializer(
       assert(!HasOffset && isa<IntegerType>(AT->getElementType()) &&
              (cast<IntegerType>(AT->getElementType())->getBitWidth() == 8));
       Global.addInitializer(
-          new Ice::GlobalAddress::ZeroInitializer(AT->getNumElements()));
+          new Ice::VariableDeclaration::ZeroInitializer(AT->getNumElements()));
     } else {
       llvm_unreachable("Unhandled constant aggregate zero type");
     }
@@ -769,18 +759,11 @@ void LLVM2ICEGlobalsConverter::addGlobalInitializer(
              TypeConverter.getIcePointerType());
       const auto GV = dyn_cast<GlobalValue>(Exp->getOperand(0));
       assert(GV);
-      if (const auto Fcn = dyn_cast<Function>(GV)) {
-        Ice::GlobalAddress::RelocationAddress Addr(Fcn);
-        Global.addInitializer(
-            new Ice::GlobalAddress::RelocInitializer(Addr, Offset));
-        return;
-      } else if (const auto Var = dyn_cast<GlobalVariable>(GV)) {
-        Ice::GlobalAddress::RelocationAddress Addr(getGlobalVarAddress(Var));
-        Global.addInitializer(
-            new Ice::GlobalAddress::RelocInitializer(Addr, Offset));
-        return;
-      }
-      break;
+      const Ice::GlobalDeclaration *Addr =
+          getConverter().getGlobalDeclaration(GV);
+      Global.addInitializer(
+          new Ice::VariableDeclaration::RelocInitializer(Addr, Offset));
+      return;
     }
     default:
       break;
@@ -797,19 +780,96 @@ void LLVM2ICEGlobalsConverter::addGlobalInitializer(
 
 namespace Ice {
 
+void Converter::nameUnnamedGlobalVariables(Module *Mod) {
+  const IceString &GlobalPrefix = Flags.DefaultGlobalPrefix;
+  if (GlobalPrefix.empty())
+    return;
+  uint32_t NameIndex = 0;
+  Ostream &errs = Ctx->getStrDump();
+  for (auto V = Mod->global_begin(), E = Mod->global_end(); V != E; ++V) {
+    if (!V->hasName()) {
+      V->setName(createUnnamedName(GlobalPrefix, NameIndex));
+      ++NameIndex;
+    } else {
+      checkIfUnnamedNameSafe(V->getName(), "global", GlobalPrefix, errs);
+    }
+  }
+}
+
+void Converter::nameUnnamedFunctions(Module *Mod) {
+  const IceString &FunctionPrefix = Flags.DefaultFunctionPrefix;
+  if (FunctionPrefix.empty())
+    return;
+  uint32_t NameIndex = 0;
+  Ostream &errs = Ctx->getStrDump();
+  for (Function &F : *Mod) {
+    if (!F.hasName()) {
+      F.setName(createUnnamedName(FunctionPrefix, NameIndex));
+      ++NameIndex;
+    } else {
+      checkIfUnnamedNameSafe(F.getName(), "function", FunctionPrefix, errs);
+    }
+  }
+}
+
 void Converter::convertToIce() {
   TimerMarker T(TimerStack::TT_convertToIce, Ctx);
-  nameUnnamedGlobalAddresses(Mod);
+  nameUnnamedGlobalVariables(Mod);
   nameUnnamedFunctions(Mod);
+  installGlobalDeclarations(Mod);
   convertGlobals(Mod);
   convertFunctions();
 }
 
+GlobalDeclaration *Converter::getGlobalDeclaration(const GlobalValue *V) {
+  GlobalDeclarationMapType::const_iterator Pos = GlobalDeclarationMap.find(V);
+  if (Pos == GlobalDeclarationMap.end()) {
+    std::string Buffer;
+    raw_string_ostream StrBuf(Buffer);
+    StrBuf << "Can't find global declaration for: " << V->getName();
+    report_fatal_error(StrBuf.str());
+  }
+  return Pos->second;
+}
+
+void Converter::installGlobalDeclarations(Module *Mod) {
+  const TypeConverter Converter(Mod->getContext());
+  // Install function declarations.
+  for (const Function &Func : *Mod) {
+    FuncSigType Signature;
+    FunctionType *FuncType = Func.getFunctionType();
+    Signature.setReturnType(
+        Converter.convertToIceType(FuncType->getReturnType()));
+    for (size_t I = 0; I < FuncType->getNumParams(); ++I) {
+      Signature.appendArgType(
+          Converter.convertToIceType(FuncType->getParamType(I)));
+    }
+    FunctionDeclaration *IceFunc = FunctionDeclaration::create(
+        Ctx, Signature, Func.getCallingConv(), Func.getLinkage(), Func.empty());
+    IceFunc->setName(Func.getName());
+    GlobalDeclarationMap[&Func] = IceFunc;
+  }
+  // Install global variable declarations.
+  for (Module::const_global_iterator I = Mod->global_begin(),
+                                     E = Mod->global_end();
+       I != E; ++I) {
+    const GlobalVariable *GV = I;
+    VariableDeclaration *Var = VariableDeclaration::create(Ctx);
+    Var->setName(GV->getName());
+    Var->setAlignment(GV->getAlignment());
+    Var->setIsConstant(GV->isConstant());
+    // Note: We allow external for cross tests.
+    // TODO(kschimpf) Put behind flag AllowUninitializedGlobals.
+    Var->setIsInternal(!GV->isExternallyInitialized());
+    GlobalDeclarationMap[GV] = Var;
+  }
+}
+
 void Converter::convertGlobals(Module *Mod) {
-  LLVM2ICEGlobalsConverter GlobalsConverter(Ctx, Mod->getContext());
-  Translator::GlobalAddressList GlobalAddresses;
-  GlobalsConverter.convertGlobalsToIce(Mod, GlobalAddresses);
-  lowerGlobals(GlobalAddresses);
+  LLVM2ICEGlobalsConverter GlobalsConverter(*this);
+  Translator::VariableDeclarationListType VariableDeclarations;
+  GlobalsConverter.convertGlobalsToIce(Mod, VariableDeclarations);
+  lowerGlobals(VariableDeclarations);
 }
 
 void Converter::convertFunctions() {
@@ -823,7 +883,7 @@ void Converter::convertFunctions() {
       TimerID = Ctx->getTimerID(StackID, I.getName());
       Ctx->pushTimer(TimerID, StackID);
     }
-    LLVM2ICEFunctionConverter FunctionConverter(Ctx, Mod->getContext());
+    LLVM2ICEFunctionConverter FunctionConverter(*this);
 
     Cfg *Fcn = FunctionConverter.convertFunction(&I);
     translateFcn(Fcn);

src/IceConverter.h

@@ -14,9 +14,11 @@
 #ifndef SUBZERO_SRC_ICECONVERTER_H
 #define SUBZERO_SRC_ICECONVERTER_H
 
+#include "IceDefs.h"
 #include "IceTranslator.h"
 
 namespace llvm {
+class GlobalValue;
 class Module;
 }
 
@@ -27,18 +29,42 @@ public:
   Converter(llvm::Module *Mod, GlobalContext *Ctx, const Ice::ClFlags &Flags)
       : Translator(Ctx, Flags), Mod(Mod) {}
 
+  ~Converter() {}
+
   /// Converts the LLVM Module to ICE. Sets exit status to false if successful,
   /// true otherwise.
   void convertToIce();
 
+  llvm::Module *getModule() const { return Mod; }
+
+  // Returns the global declaration associated with the corresponding
+  // global value V. If no such global address, generates fatal error.
+  GlobalDeclaration *getGlobalDeclaration(const llvm::GlobalValue *V);
+
 private:
   llvm::Module *Mod;
+  typedef std::map<const llvm::GlobalValue *, GlobalDeclaration *>
+      GlobalDeclarationMapType;
+  GlobalDeclarationMapType GlobalDeclarationMap;
+
+  // Walks module and generates names for unnamed globals using prefix
+  // getFlags().DefaultGlobalPrefix, if the prefix is non-empty.
+  void nameUnnamedGlobalVariables(llvm::Module *Mod);
+
+  // Walks module and generates names for unnamed functions using
+  // prefix getFlags().DefaultFunctionPrefix, if the prefix is
+  // non-empty.
+  void nameUnnamedFunctions(llvm::Module *Mod);
+
   // Converts functions to ICE, and then machine code.
   void convertFunctions();
 
   // Converts globals to ICE, and then machine code.
   void convertGlobals(llvm::Module *Mod);
 
+  // Installs global declarations into GlobalDeclarationMap.
+  void installGlobalDeclarations(llvm::Module *Mod);
+
   Converter(const Converter &) = delete;
   Converter &operator=(const Converter &) = delete;
 };

src/IceDefs.h

@@ -26,7 +26,6 @@
 #include <set>
 #include <string>
 #include <vector>
-
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/BitVector.h"
 #include "llvm/ADT/SmallBitVector.h"
@@ -39,7 +38,9 @@ namespace Ice {
 class Cfg;
 class CfgNode;
 class Constant;
+class FunctionDeclaration;
 class GlobalContext;
+class GlobalDeclaration;
 class Inst;
 class InstPhi;
 class InstTarget;
@@ -48,6 +49,7 @@ class Liveness;
 class Operand;
 class TargetLowering;
 class Variable;
+class VariableDeclaration;
 class VariablesMetadata;
 
 // TODO: Switch over to LLVM's ADT container classes.

src/IceGlobalContext.cpp

@@ -19,6 +19,7 @@
 #include "IceClFlags.h"
 #include "IceDefs.h"
 #include "IceGlobalContext.h"
+#include "IceGlobalInits.h"
 #include "IceOperand.h"
 #include "IceTargetLowering.h"
 #include "IceTimerTree.h"
@@ -289,7 +290,9 @@ IceString GlobalContext::mangleName(const IceString &Name) const {
   return getTestPrefix() + Name;
 }
 
-GlobalContext::~GlobalContext() {}
+GlobalContext::~GlobalContext() {
+  llvm::DeleteContainerPointers(GlobalDeclarations);
+}
 
 Constant *GlobalContext::getConstantInt64(Type Ty, uint64_t ConstantInt64) {
   assert(Ty == IceType_i64);
@@ -385,6 +388,23 @@ ConstantList GlobalContext::getConstantPool(Type Ty) const {
   llvm_unreachable("Unknown type");
 }
 
+FunctionDeclaration *
+GlobalContext::newFunctionDeclaration(const FuncSigType *Signature,
+                                      unsigned CallingConv, unsigned Linkage,
+                                      bool IsProto) {
+  FunctionDeclaration *Func = new FunctionDeclaration(
+      *Signature, static_cast<llvm::CallingConv::ID>(CallingConv),
+      static_cast<llvm::GlobalValue::LinkageTypes>(Linkage), IsProto);
+  GlobalDeclarations.push_back(Func);
+  return Func;
+}
+
+VariableDeclaration *GlobalContext::newVariableDeclaration() {
+  VariableDeclaration *Var = new VariableDeclaration();
+  GlobalDeclarations.push_back(Var);
+  return Var;
+}
+
 TimerIdT GlobalContext::getTimerID(TimerStackIdT StackID,
                                    const IceString &Name) {
   assert(StackID < Timers.size());

src/IceGlobalContext.h

@@ -21,6 +21,7 @@
 #include "llvm/Support/raw_ostream.h"
 
 #include "IceDefs.h"
+#include "IceClFlags.h"
 #include "IceIntrinsics.h"
 #include "IceRNG.h"
 #include "IceTimerTree.h"
@@ -29,6 +30,7 @@
 namespace Ice {
 
 class ClFlags;
+class FuncSigType;
 
 // This class collects rudimentary statistics during translation.
 class CodeStats {
@@ -117,6 +119,17 @@ public:
   // getConstantPool() returns a copy of the constant pool for
   // constants of a given type.
   ConstantList getConstantPool(Type Ty) const;
+  // Returns a new function declaration, allocated in an internal
+  // memory pool.  Ownership of the function is maintained by this
+  // class instance.
+  FunctionDeclaration *newFunctionDeclaration(const FuncSigType *Signature,
+                                              unsigned CallingConv,
+                                              unsigned Linkage, bool IsProto);
+
+  // Returns a new global variable declaration, allocated in an
+  // internal memory pool.  Ownership of the function is maintained by
+  // this class instance.
+  VariableDeclaration *newVariableDeclaration();
 
   const ClFlags &getFlags() const { return Flags; }
 
@@ -186,6 +199,7 @@ private:
   CodeStats StatsFunction;
   CodeStats StatsCumulative;
   std::vector<TimerStack> Timers;
+  std::vector<GlobalDeclaration *> GlobalDeclarations;
   GlobalContext(const GlobalContext &) = delete;
   GlobalContext &operator=(const GlobalContext &) = delete;
 

src/IceGlobalInits.cpp

-//===- subzero/src/IceGlobalInits.cpp - Global initializers ---------------===//
+//===- subzero/src/IceGlobalInits.cpp - Global declarations ---------------===//
 //
 //                        The Subzero Code Generator
 //
@@ -7,8 +7,9 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// This file implements the notion of global addresses and
-// initializers in Subzero.
+// This file implements the notion of function declarations, global
+// variable declarations, and the corresponding variable initializers
+// in Subzero.
 //
 //===----------------------------------------------------------------------===//
 
@@ -17,18 +18,82 @@
 #include "llvm/IR/Value.h"
 
 #include "IceDefs.h"
+#include "IceGlobalContext.h"
 #include "IceGlobalInits.h"
 #include "IceTypes.h"
 
 namespace {
 char hexdigit(unsigned X) { return X < 10 ? '0' + X : 'A' + X - 10; }
+
+void dumpLinkage(Ice::Ostream &Stream,
+                 llvm::GlobalValue::LinkageTypes Linkage) {
+  switch (Linkage) {
+  case llvm::GlobalValue::ExternalLinkage:
+    Stream << "external";
+    return;
+  case llvm::GlobalValue::InternalLinkage:
+    Stream << "internal";
+    return;
+  default:
+    break;
+  }
+  std::string Buffer;
+  llvm::raw_string_ostream StrBuf(Buffer);
+  StrBuf << "Unknown linkage value: " << Linkage;
+  llvm::report_fatal_error(StrBuf.str());
 }
 
+void dumpCallingConv(Ice::Ostream &, llvm::CallingConv::ID CallingConv) {
+  if (CallingConv == llvm::CallingConv::C)
+    return;
+  std::string Buffer;
+  llvm::raw_string_ostream StrBuf(Buffer);
+  StrBuf << "Unknown calling convention: " << CallingConv;
+  llvm::report_fatal_error(StrBuf.str());
+}
+
+} // end of anonymous namespace
+
 namespace Ice {
 
-GlobalAddress::~GlobalAddress() { llvm::DeleteContainerPointers(Initializers); }
+FunctionDeclaration *
+FunctionDeclaration::create(GlobalContext *Ctx, const FuncSigType &Signature,
+                            llvm::CallingConv::ID CallingConv,
+                            llvm::GlobalValue::LinkageTypes Linkage,
+                            bool IsProto) {
+  return Ctx->newFunctionDeclaration(&Signature, CallingConv, Linkage, IsProto);
+}
+
+void FunctionDeclaration::dumpType(Ostream &Stream) const {
+  Stream << Signature;
+}
+
+void FunctionDeclaration::dump(Ostream &Stream) const {
+  if (IsProto)
+    Stream << "declare ";
+  ::dumpLinkage(Stream, Linkage);
+  ::dumpCallingConv(Stream, CallingConv);
+  Stream << Signature.getReturnType() << " @" << Name << "(";
+  bool IsFirst = true;
+  for (Type ArgTy : Signature.getArgList()) {
+    if (IsFirst)
+      IsFirst = false;
+    else
+      Stream << ", ";
+    Stream << ArgTy;
+  }
+  Stream << ")";
+}
+
+VariableDeclaration *VariableDeclaration::create(GlobalContext *Ctx) {
+  return Ctx->newVariableDeclaration();
+}
 
-void GlobalAddress::dumpType(Ostream &Stream) const {
+VariableDeclaration::~VariableDeclaration() {
+  llvm::DeleteContainerPointers(Initializers);
+}
+
+void VariableDeclaration::dumpType(Ostream &Stream) const {
   if (Initializers.size() == 1) {
     Initializers.front()->dumpType(Stream);
   } else {
@@ -46,8 +111,8 @@ void GlobalAddress::dumpType(Ostream &Stream) const {
   }
 }
 
-void GlobalAddress::dump(Ostream &Stream) const {
-  Stream << "@" << getName() << " = internal "
+void VariableDeclaration::dump(Ostream &Stream) const {
+  Stream << "@" << Name << " = internal "
          << (IsConstant ? "constant" : "global") << " ";
 
   // Add initializer.
@@ -74,11 +139,11 @@ void GlobalAddress::dump(Ostream &Stream) const {
   Stream << "\n";
 }
 
-void GlobalAddress::Initializer::dumpType(Ostream &Stream) const {
+void VariableDeclaration::Initializer::dumpType(Ostream &Stream) const {
   Stream << "[" << getNumBytes() << " x " << Ice::IceType_i8 << "]";
 }
 
-void GlobalAddress::DataInitializer::dump(Ostream &Stream) const {
+void VariableDeclaration::DataInitializer::dump(Ostream &Stream) const {
   dumpType(Stream);
   Stream << " c\"";
   // Code taken from PrintEscapedString() in AsmWriter.cpp.  Keep
@@ -93,41 +158,24 @@ void GlobalAddress::DataInitializer::dump(Ostream &Stream) const {
   Stream << "\"";
 }
 
-void GlobalAddress::ZeroInitializer::dump(Ostream &Stream) const {
+void VariableDeclaration::ZeroInitializer::dump(Ostream &Stream) const {
   dumpType(Stream);
   Stream << " zeroinitializer";
 }
 
-IceString GlobalAddress::RelocInitializer::getName() const {
-  switch (Address.getKind()) {
-  case FunctionRelocation:
-    return Address.getFunction()->getName();
-  case GlobalAddressRelocation:
-    return Address.getGlobalAddr()->getName();
-  default:
-    llvm::report_fatal_error("Malformed relocation address!");
-  }
-}
-
-void GlobalAddress::RelocInitializer::dumpType(Ostream &Stream) const {
+void VariableDeclaration::RelocInitializer::dumpType(Ostream &Stream) const {
   Stream << Ice::IceType_i32;
 }
 
-void GlobalAddress::RelocInitializer::dump(Ostream &Stream) const {
+void VariableDeclaration::RelocInitializer::dump(Ostream &Stream) const {
   if (Offset != 0) {
     dumpType(Stream);
     Stream << " add (";
   }
   dumpType(Stream);
   Stream << " ptrtoint (";
-  if (Address.getKind() == FunctionRelocation) {
-    Stream << *Address.getFunction()->getType() << " @"
-           << Address.getFunction()->getName();
-  } else {
-    Address.getGlobalAddr()->dumpType(Stream);
-    Stream << "* @" << Address.getGlobalAddr()->getName();
-  }
-  Stream << " to ";
+  Declaration->dumpType(Stream);
+  Stream << "* @" << Declaration->getName() << " to ";
   dumpType(Stream);
   Stream << ")";
   if (Offset != 0) {
@@ -136,4 +184,5 @@ void GlobalAddress::RelocInitializer::dump(Ostream &Stream) const {
     Stream << " " << Offset << ")";
   }
 }
-}
+
+} // end of namespace Ice

src/IceGlobalInits.h

-//===- subzero/src/IceGlobalInits.h - Global initializers -------*- C++ -*-===//
+//===- subzero/src/IceGlobalInits.h - Global declarations -------*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
@@ -7,29 +7,117 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// This file declares the representation of global addresses and
-// initializers in Subzero. Global initializers are represented as a
-// sequence of simple initializers.
+// This file declares the representation of function declarations,
+// global variable declarations, and the corresponding variable
+// initializers in Subzero. Global variable initializers are
+// represented as a sequence of simple initializers.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SUBZERO_SRC_ICEGLOBALINITS_H
 #define SUBZERO_SRC_ICEGLOBALINITS_H
 
+#include "llvm/IR/CallingConv.h"
+#include "llvm/IR/GlobalValue.h" // for GlobalValue::LinkageTypes
+
 #include "IceDefs.h"
+#include "IceTypes.h"
 
-namespace llvm {
-// TODO(kschimpf): Remove this dependency on LLVM IR.
-class Value;
-}
+// TODO(kschimpf): Remove ourselves from using LLVM representation for calling
+// conventions and linkage types.
 
 namespace Ice {
 
-/// Models a global address, and its initializers.
-class GlobalAddress {
-  GlobalAddress(const GlobalAddress &) = delete;
-  GlobalAddress &operator=(const GlobalAddress &) = delete;
+/// Base class for global variable and function declarations.
+class GlobalDeclaration {
+  GlobalDeclaration(const GlobalDeclaration &) = delete;
+  GlobalDeclaration &operator=(const GlobalDeclaration &) = delete;
+
+public:
+  /// Discriminator for LLVM-style RTTI.
+  enum GlobalDeclarationKind {
+    FunctionDeclarationKind,
+    VariableDeclarationKind
+  };
+  GlobalDeclarationKind getKind() const { return Kind; }
+  const IceString &getName() const { return Name; }
+  void setName(const IceString &NewName) { Name = NewName; }
+  bool hasName() const { return !Name.empty(); }
+  virtual ~GlobalDeclaration() {}
+
+  /// Returns true if the declaration is external.
+  virtual bool getIsExternal() const = 0;
+
+  /// Prints out type of the global declaration.
+  virtual void dumpType(Ostream &Stream) const = 0;
+
+  /// Prints out the global declaration.
+  virtual void dump(Ostream &Stream) const = 0;
+
+  // Mangles name for cross tests, unless external and not defined locally
+  // (so that relocations accross llvm2ice and pnacl-llc will work).
+  virtual IceString mangleName(GlobalContext *Ctx) const = 0;
+
+protected:
+  GlobalDeclaration(GlobalDeclarationKind Kind) : Kind(Kind) {}
+
+  const GlobalDeclarationKind Kind;
+  IceString Name;
+};
+
+// Models a function declaration. This includes the type signature of
+// the function, its calling conventions, and its linkage.
+class FunctionDeclaration : public GlobalDeclaration {
+  FunctionDeclaration(const FunctionDeclaration &) = delete;
+  FunctionDeclaration &operator=(const FunctionDeclaration &) = delete;
+  friend class GlobalContext;
+
+public:
+  static FunctionDeclaration *create(GlobalContext *Ctx,
+                                     const FuncSigType &Signature,
+                                     llvm::CallingConv::ID CallingConv,
+                                     llvm::GlobalValue::LinkageTypes Linkage,
+                                     bool IsProto);
+  ~FunctionDeclaration() final {}
+  const FuncSigType &getSignature() const { return Signature; }
+  llvm::CallingConv::ID getCallingConv() const { return CallingConv; }
+  llvm::GlobalValue::LinkageTypes getLinkage() const { return Linkage; }
+  // isProto implies that there isn't a (local) definition for the function.
+  bool isProto() const { return IsProto; }
+  static bool classof(const GlobalDeclaration *Addr) {
+    return Addr->getKind() == FunctionDeclarationKind;
+  }
+  void dumpType(Ostream &Stream) const final;
+  void dump(Ostream &Stream) const final;
+  bool getIsExternal() const final {
+    return Linkage == llvm::GlobalValue::ExternalLinkage;
+  }
+
+  virtual IceString mangleName(GlobalContext *Ctx) const final {
+    return (getIsExternal() && IsProto) ? Name : Ctx->mangleName(Name);
+  }
+
+private:
+  const Ice::FuncSigType Signature;
+  llvm::CallingConv::ID CallingConv;
+  llvm::GlobalValue::LinkageTypes Linkage;
+  bool IsProto;
+
+  FunctionDeclaration(const FuncSigType &Signature,
+                      llvm::CallingConv::ID CallingConv,
+                      llvm::GlobalValue::LinkageTypes Linkage, bool IsProto)
+      : GlobalDeclaration(FunctionDeclarationKind), Signature(Signature),
+        CallingConv(CallingConv), Linkage(Linkage), IsProto(IsProto) {}
+};
 
+/// Models a global variable declaration, and its initializers.
+class VariableDeclaration : public GlobalDeclaration {
+  VariableDeclaration(const VariableDeclaration &) = delete;
+  VariableDeclaration &operator=(const VariableDeclaration &) = delete;
+  friend class GlobalContext;
+  // TODO(kschimpf) Factor out allocation of initializers into the
+  // global context, so that memory allocation/collection can be
+  // optimized.
 public:
   /// Base class for a global variable initializer.
   class Initializer {
@@ -81,8 +169,8 @@ public:
     }
     ~DataInitializer() override {}
     const DataVecType &getContents() const { return Contents; }
-    SizeT getNumBytes() const override { return Contents.size(); }
-    void dump(Ostream &Stream) const override;
+    SizeT getNumBytes() const final { return Contents.size(); }
+    void dump(Ostream &Stream) const final;
     static bool classof(const Initializer *D) {
       return D->getKind() == DataInitializerKind;
     }
@@ -101,8 +189,8 @@ public:
     explicit ZeroInitializer(SizeT Size)
         : Initializer(ZeroInitializerKind), Size(Size) {}
     ~ZeroInitializer() override {}
-    SizeT getNumBytes() const override { return Size; }
-    void dump(Ostream &Stream) const override;
+    SizeT getNumBytes() const final { return Size; }
+    void dump(Ostream &Stream) const final;
     static bool classof(const Initializer *Z) {
       return Z->getKind() == ZeroInitializerKind;
     }
@@ -112,76 +200,33 @@ public:
     SizeT Size;
   };
 
-  /// Defines the kind of relocation addresses allowed.
-  enum RelocationKind { FunctionRelocation, GlobalAddressRelocation };
-
-  /// Defines a relocation address (i.e. reference to a function
-  /// or global variable address).
-  class RelocationAddress {
-    RelocationAddress &operator=(const RelocationAddress &) = delete;
-
-  public:
-    explicit RelocationAddress(const RelocationAddress &Addr)
-        : Kind(Addr.Kind) {
-      switch (Kind) {
-      case FunctionRelocation:
-        Address.Function = Addr.Address.Function;
-        break;
-      case GlobalAddressRelocation:
-        Address.GlobalAddr = Addr.Address.GlobalAddr;
-      }
-    }
-    explicit RelocationAddress(llvm::Value *Function)
-        : Kind(FunctionRelocation) {
-      Address.Function = Function;
-    }
-    explicit RelocationAddress(GlobalAddress *GlobalAddr)
-        : Kind(GlobalAddressRelocation) {
-      Address.GlobalAddr = GlobalAddr;
-    }
-    RelocationKind getKind() const { return Kind; }
-    llvm::Value *getFunction() const {
-      assert(Kind == FunctionRelocation);
-      return Address.Function;
-    }
-    GlobalAddress *getGlobalAddr() const {
-      assert(Kind == GlobalAddressRelocation);
-      return Address.GlobalAddr;
-    }
-  private:
-    const RelocationKind Kind;
-    union {
-      // TODO(kschimpf) Integrate Functions into ICE model.
-      llvm::Value *Function;
-      GlobalAddress *GlobalAddr;
-    } Address;
-  };
-
   // Relocation address offsets must be 32 bit values.
   typedef int32_t RelocOffsetType;
   static const SizeT RelocAddrSize = 4;
 
-  /// Defines the relocation value of another address.
+  /// Defines the relocation value of another global declaration.
   class RelocInitializer : public Initializer {
     RelocInitializer(const RelocInitializer &) = delete;
     RelocInitializer &operator=(const RelocInitializer &) = delete;
 
   public:
-    RelocInitializer(const RelocationAddress &Address, RelocOffsetType Offset)
-        : Initializer(RelocInitializerKind), Address(Address), Offset(Offset) {}
+    RelocInitializer(const GlobalDeclaration *Declaration,
+                     RelocOffsetType Offset)
+        : Initializer(RelocInitializerKind), Declaration(Declaration),
+          Offset(Offset) {}
     ~RelocInitializer() override {}
     RelocOffsetType getOffset() const { return Offset; }
-    IceString getName() const;
-    SizeT getNumBytes() const override { return RelocAddrSize; }
-    void dump(Ostream &Stream) const override;
-    virtual void dumpType(Ostream &Stream) const;
+    const GlobalDeclaration *getDeclaration() const { return Declaration; }
+    SizeT getNumBytes() const final { return RelocAddrSize; }
+    void dump(Ostream &Stream) const final;
+    void dumpType(Ostream &Stream) const final;
     static bool classof(const Initializer *R) {
       return R->getKind() == RelocInitializerKind;
     }
 
   private:
-    // The global address used in the relocation.
-    const RelocationAddress Address;
+    // The global declaration used in the relocation.
+    const GlobalDeclaration *Declaration;
     // The offset to add to the relocation.
     const RelocOffsetType Offset;
   };
@@ -189,19 +234,21 @@ public:
   /// Models the list of initializers.
   typedef std::vector<Initializer *> InitializerListType;
 
-  GlobalAddress() : Alignment(0), IsConstant(false), IsInternal(true) {}
-  ~GlobalAddress();
+  static VariableDeclaration *create(GlobalContext *Ctx);
+  ~VariableDeclaration() final;
 
   const InitializerListType &getInitializers() const { return Initializers; }
-  bool hasName() const { return !Name.empty(); }
-  const IceString &getName() const { return Name; }
-  void setName(const IceString &NewName) { Name = NewName; }
   bool getIsConstant() const { return IsConstant; }
   void setIsConstant(bool NewValue) { IsConstant = NewValue; }
   uint32_t getAlignment() const { return Alignment; }
   void setAlignment(uint32_t NewAlignment) { Alignment = NewAlignment; }
   bool getIsInternal() const { return IsInternal; }
   void setIsInternal(bool NewValue) { IsInternal = NewValue; }
+  bool getIsExternal() const final { return !getIsInternal(); }
+  bool hasInitializer() const {
+    return !(Initializers.size() == 1 &&
+             llvm::isa<ZeroInitializer>(Initializers[0]));
+  }
 
   /// Returns the number of bytes for the initializer of the global
   /// address.
@@ -219,36 +266,49 @@ public:
     Initializers.push_back(Initializer);
   }
 
-  /// Prints out type for initializer associated with the global address
+  /// Prints out type for initializer associated with the declaration
   /// to Stream.
-  void dumpType(Ostream &Stream) const;
+  void dumpType(Ostream &Stream) const final;
+
+  /// Prints out the definition of the global variable declaration
+  /// (including initialization).
+  void dump(Ostream &Stream) const final;
+
+  static bool classof(const GlobalDeclaration *Addr) {
+    return Addr->getKind() == VariableDeclarationKind;
+  }
+
+  IceString mangleName(GlobalContext *Ctx) const final {
+    return (getIsExternal() && !hasInitializer())
+        ? Name : Ctx->mangleName(Name);
+  }
 
-  /// Prints out the definition of the global address (including
-  /// initialization).
-  void dump(Ostream &Stream) const;
 
 private:
-  // list of initializers associated with the global address.
+  // list of initializers for the declared variable.
   InitializerListType Initializers;
-  // The name for the global.
-  IceString Name;
-  // The alignment of the initializer.
+  // The alignment of the declared variable.
   uint32_t Alignment;
-  // True if a constant initializer.
+  // True if a declared (global) constant.
   bool IsConstant;
-  // True if the address is internal.
+  // True if the declaration is internal.
   bool IsInternal;
+
+  VariableDeclaration()
+      : GlobalDeclaration(VariableDeclarationKind), Alignment(0),
+        IsConstant(false), IsInternal(true) {}
 };
 
 template <class StreamType>
 inline StreamType &operator<<(StreamType &Stream,
-                              const GlobalAddress::Initializer &Init) {
+                              const VariableDeclaration::Initializer &Init) {
   Init.dump(Stream);
   return Stream;
 }
 
 template <class StreamType>
-inline StreamType &operator<<(StreamType &Stream, const GlobalAddress &Addr) {
+inline StreamType &operator<<(StreamType &Stream,
+                              const GlobalDeclaration &Addr) {
   Addr.dump(Stream);
   return Stream;
 }

src/IceTargetLowering.h

@@ -27,7 +27,6 @@ namespace Ice {
 typedef uint8_t AsmCodeByte;
 
 class Assembler;
-class GlobalAddress;
 
 // LoweringContext makes it easy to iterate through non-deleted
 // instructions in a node, and insert new (lowered) instructions at
@@ -249,7 +248,7 @@ public:
                                                   GlobalContext *Ctx);
   virtual ~TargetGlobalInitLowering();
 
-  virtual void lower(const GlobalAddress &Addr, bool DisableTranslation) = 0;
+  virtual void lower(const VariableDeclaration &Var) = 0;
 
 protected:
   TargetGlobalInitLowering(GlobalContext *Ctx) : Ctx(Ctx) {}

src/IceTargetLoweringX8632.cpp

@@ -4427,32 +4427,19 @@ void ConstantUndef::emit(GlobalContext *) const {
 TargetGlobalInitX8632::TargetGlobalInitX8632(GlobalContext *Ctx)
     : TargetGlobalInitLowering(Ctx) {}
 
-void TargetGlobalInitX8632::lower(const GlobalAddress &Global,
-                                  bool DisableTranslation) {
-  if (Ctx->isVerbose()) {
-    Global.dump(Ctx->getStrDump());
-  }
-
-  if (DisableTranslation)
-    return;
+void TargetGlobalInitX8632::lower(const VariableDeclaration &Var) {
 
   Ostream &Str = Ctx->getStrEmit();
 
-  // TODO(kschimpf): Don't mangle name if external and uninitialized. This
-  // will allow us to cross test relocations for references to external
-  // global variables.
-
-  const GlobalAddress::InitializerListType &Initializers =
-      Global.getInitializers();
+  const VariableDeclaration::InitializerListType &Initializers =
+      Var.getInitializers();
   assert(Initializers.size());
-  bool HasInitializer =
-      !(Initializers.size() == 1 &&
-        llvm::isa<GlobalAddress::ZeroInitializer>(Initializers[0]));
-  bool IsConstant = Global.getIsConstant();
-  bool IsExternal = !Global.getIsInternal();
-  uint32_t Align = Global.getAlignment();
-  SizeT Size = Global.getNumBytes();
-  IceString MangledName = Ctx->mangleName(Global.getName());
+  bool HasInitializer = Var.hasInitializer();
+  bool IsConstant = Var.getIsConstant();
+  bool IsExternal = Var.getIsExternal();
+  uint32_t Align = Var.getAlignment();
+  SizeT Size = Var.getNumBytes();
+  IceString MangledName = Var.mangleName(Ctx);
   IceString SectionSuffix = "";
   if (Ctx->getFlags().DataSections)
     SectionSuffix = "." + MangledName;
@@ -4483,30 +4470,29 @@ void TargetGlobalInitX8632::lower(const GlobalAddress &Global,
     Str << "\t.comm\t" << MangledName << "," << Size << "," << Align << "\n";
 
   if (HasInitializer) {
-    for (GlobalAddress::Initializer *Init : Initializers) {
+    for (VariableDeclaration::Initializer *Init : Initializers) {
       switch (Init->getKind()) {
-      case GlobalAddress::Initializer::DataInitializerKind: {
-        const auto Data =
-            llvm::cast<GlobalAddress::DataInitializer>(Init)->getContents();
+      case VariableDeclaration::Initializer::DataInitializerKind: {
+        const auto Data = llvm::cast<VariableDeclaration::DataInitializer>(Init)
+                              ->getContents();
         for (SizeT i = 0; i < Init->getNumBytes(); ++i) {
           Str << "\t.byte\t" << (((unsigned)Data[i]) & 0xff) << "\n";
         }
         break;
       }
-      case GlobalAddress::Initializer::ZeroInitializerKind:
+      case VariableDeclaration::Initializer::ZeroInitializerKind:
         Str << "\t.zero\t" << Init->getNumBytes() << "\n";
         break;
-      case GlobalAddress::Initializer::RelocInitializerKind: {
-        const auto Reloc = llvm::cast<GlobalAddress::RelocInitializer>(Init);
+      case VariableDeclaration::Initializer::RelocInitializerKind: {
+        const auto Reloc =
+            llvm::cast<VariableDeclaration::RelocInitializer>(Init);
         Str << "\t.long\t";
-        // TODO(kschimpf): Once the representation of a relocation has
-        // been modified to reference the corresponding global
-        // address, modify to not mangle the name if the global is
-        // external and uninitialized. This will allow us to better
-        // test cross test relocations.
-        Str << Ctx->mangleName(Reloc->getName());
-        if (GlobalAddress::RelocOffsetType Offset = Reloc->getOffset()) {
-          Str << " + " << Offset;
+        Str << Reloc->getDeclaration()->mangleName(Ctx);
+        if (VariableDeclaration::RelocOffsetType Offset = Reloc->getOffset()) {
+          if (Offset >= 0 || (Offset == INT32_MIN))
+            Str << " + " << Offset;
+          else
+            Str << " - " << -Offset;
         }
         Str << "\n";
         break;

src/IceTargetLoweringX8632.h

@@ -482,8 +482,7 @@ public:
     return new TargetGlobalInitX8632(Ctx);
   }
 
-  virtual void lower(const GlobalAddress &Addr,
-                     bool DisableTranslation) override;
+  virtual void lower(const VariableDeclaration &Var) final;
 
 protected:
   TargetGlobalInitX8632(GlobalContext *Ctx);

src/IceTranslator.cpp

@@ -22,6 +22,7 @@
 #include "IceCfg.h"
 #include "IceClFlags.h"
 #include "IceDefs.h"
+#include "IceGlobalInits.h"
 #include "IceTargetLowering.h"
 #include "IceTranslator.h"
 
@@ -54,38 +55,6 @@ bool Translator::checkIfUnnamedNameSafe(const IceString &Name, const char *Kind,
   return false;
 }
 
-void Translator::nameUnnamedGlobalAddresses(llvm::Module *Mod) {
-  const IceString &GlobalPrefix = Flags.DefaultGlobalPrefix;
-  if (GlobalPrefix.empty())
-    return;
-  uint32_t NameIndex = 0;
-  Ostream &errs = Ctx->getStrDump();
-  for (auto V = Mod->global_begin(), E = Mod->global_end(); V != E; ++V) {
-    if (!V->hasName()) {
-      V->setName(createUnnamedName(GlobalPrefix, NameIndex));
-      ++NameIndex;
-    } else {
-      checkIfUnnamedNameSafe(V->getName(), "global", GlobalPrefix, errs);
-    }
-  }
-}
-
-void Translator::nameUnnamedFunctions(llvm::Module *Mod) {
-  const IceString &FunctionPrefix = Flags.DefaultFunctionPrefix;
-  if (FunctionPrefix.empty())
-    return;
-  uint32_t NameIndex = 0;
-  Ostream &errs = Ctx->getStrDump();
-  for (llvm::Function &F : *Mod) {
-    if (!F.hasName()) {
-      F.setName(createUnnamedName(FunctionPrefix, NameIndex));
-      ++NameIndex;
-    } else {
-      checkIfUnnamedNameSafe(F.getName(), "function", FunctionPrefix, errs);
-    }
-  }
-}
-
 void Translator::translateFcn(Cfg *Fcn) {
   Ctx->resetStats();
   Func.reset(Fcn);
@@ -110,12 +79,18 @@ void Translator::emitConstants() {
     Func->getTarget()->emitConstants();
 }
 
-void Translator::lowerGlobals(const GlobalAddressList &GlobalAddresses) {
-  llvm::OwningPtr<Ice::TargetGlobalInitLowering> GlobalLowering(
-      Ice::TargetGlobalInitLowering::createLowering(Ctx->getTargetArch(), Ctx));
+void Translator::lowerGlobals(
+    const VariableDeclarationListType &VariableDeclarations) {
+  llvm::OwningPtr<TargetGlobalInitLowering> GlobalLowering(
+      TargetGlobalInitLowering::createLowering(Ctx->getTargetArch(), Ctx));
   bool DisableTranslation = Ctx->getFlags().DisableTranslation;
-  for (const Ice::GlobalAddress *Addr : GlobalAddresses) {
-    GlobalLowering->lower(*Addr, DisableTranslation);
+  bool DumpGlobalVariables = Ctx->isVerbose();
+  Ostream &Stream = Ctx->getStrDump();
+  for (const Ice::VariableDeclaration *Global : VariableDeclarations) {
+    if (DumpGlobalVariables)
+      Global->dump(Stream);
+    if(!DisableTranslation)
+      GlobalLowering->lower(*Global);
   }
   GlobalLowering.reset();
 }

src/IceTranslator.h

@@ -25,16 +25,15 @@ namespace Ice {
 
 class ClFlags;
 class Cfg;
-class GlobalAddress;
+class VariableDeclaration;
 class GlobalContext;
 
-// Base class for translating ICE to machine code.
-// Derived classes convert other intermediate representations down to ICE,
-// and then call the appropriate (inherited) methods to convert ICE into
-// machine instructions.
+// Base class for translating ICE to machine code.  Derived classes convert
+// other intermediate representations down to ICE, and then call the appropriate
+// (inherited) methods to convert ICE into machine instructions.
 class Translator {
 public:
-  typedef std::vector<Ice::GlobalAddress *> GlobalAddressList;
+  typedef std::vector<VariableDeclaration *> VariableDeclarationListType;
 
   Translator(GlobalContext *Ctx, const ClFlags &Flags)
       : Ctx(Ctx), Flags(Flags), ErrorStatus(0) {}
@@ -54,8 +53,9 @@ public:
   /// Emits the constant pool.
   void emitConstants();
 
-  /// Lowers the given list of global addresses to target.
-  void lowerGlobals(const GlobalAddressList &GlobalAddresses);
+  /// Lowers the given list of global addresses to target. Generates
+  /// list of corresponding variable declarations.
+  void lowerGlobals(const VariableDeclarationListType &VariableDeclarations);
 
   /// Creates a name using the given prefix and corresponding index.
   std::string createUnnamedName(const IceString &Prefix, SizeT Index);
@@ -66,15 +66,6 @@ public:
   bool checkIfUnnamedNameSafe(const IceString &Name, const char *Kind,
                               const IceString &Prefix, Ostream &Stream);
 
-  // Walks module and generates names for unnamed globals using prefix
-  // getFlags().DefaultGlobalPrefix, if the prefix is non-empty.
-  void nameUnnamedGlobalAddresses(llvm::Module *Mod);
-
-  // Walks module and generates names for unnamed functions using
-  // prefix getFlags().DefaultFunctionPrefix, if the prefix is
-  // non-empty.
-  void nameUnnamedFunctions(llvm::Module *Mod);
-
 protected:
   GlobalContext *Ctx;
   const ClFlags &Flags;

src/PNaClTranslator.cpp

@@ -24,7 +24,6 @@
 #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"
@@ -36,9 +35,8 @@
 #include "IceTypeConverter.h"
 #include "PNaClTranslator.h"
 
-using namespace llvm;
-
 namespace {
+using namespace llvm;
 
 // TODO(kschimpf) Remove error recovery once implementation complete.
 static cl::opt<bool> AllowErrorRecovery(
@@ -160,19 +158,21 @@ class TopLevelParser : public NaClBitcodeParser {
   TopLevelParser &operator=(const TopLevelParser &) = delete;
 
 public:
+  typedef std::vector<Ice::FunctionDeclaration *> FunctionDeclarationListType;
+
   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()),
+        Header(Header), TypeConverter(Mod->getContext()),
         ErrorStatus(ErrorStatus), NumErrors(0), NumFunctionIds(0),
         NumFunctionBlocks(0) {
     Mod->setDataLayout(PNaClDataLayout);
     setErrStream(Translator.getContext()->getStrDump());
   }
 
-  ~TopLevelParser() override { DeleteContainerPointers(GlobalIDAddresses); }
+  ~TopLevelParser() override {}
 
   Ice::Translator &getTranslator() { return Translator; }
 
@@ -198,9 +198,6 @@ public:
   /// 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); }
 
@@ -236,36 +233,40 @@ public:
   }
 
   /// Sets the next function ID to the given LLVM function.
-  void setNextFunctionID(Function *Fcn) {
+  void setNextFunctionID(Ice::FunctionDeclaration *Fcn) {
     ++NumFunctionIds;
-    FunctionIDValues.push_back(Fcn);
+    FunctionDeclarationList.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(FunctionIDValues.size());
+    DefiningFunctionDeclarationsList.push_back(FunctionDeclarationList.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())
+    if (NumFunctionBlocks >= DefiningFunctionDeclarationsList.size())
       report_fatal_error(
           "More function blocks than defined function addresses");
-    return DefiningFunctionsList[NumFunctionBlocks++];
+    return DefiningFunctionDeclarationsList[NumFunctionBlocks++];
   }
 
-  /// Returns the LLVM Function address associated with ID.
-  Function *getFunctionByID(unsigned ID) const {
-    if (ID >= FunctionIDValues.size())
-      return nullptr;
-    Value *V = FunctionIDValues[ID];
-    return cast<Function>(V);
+  /// Returns the function associated with ID.
+  Ice::FunctionDeclaration *getFunctionByID(unsigned ID) {
+    if (ID < FunctionDeclarationList.size())
+      return FunctionDeclarationList[ID];
+    return reportGetFunctionByIDError(ID);
   }
 
-  /// Returns the corresponding constant associated with a global value
+  /// Returns the list of function declarations.
+  const FunctionDeclarationListType &getFunctionDeclarationList() const {
+    return FunctionDeclarationList;
+  }
+
+  /// Returns the corresponding constant associated with a global declaration.
   /// (i.e. relocatable).
   Ice::Constant *getOrCreateGlobalConstantByID(unsigned ID) {
     // TODO(kschimpf): Can this be built when creating global initializers?
@@ -273,7 +274,7 @@ public:
     if (ID >= ValueIDConstants.size()) {
       C = nullptr;
       unsigned ExpectedSize =
-          FunctionIDValues.size() + GlobalIDAddresses.size();
+          FunctionDeclarationList.size() + VariableDeclarations.size();
       if (ID >= ExpectedSize)
         ExpectedSize = ID;
       ValueIDConstants.resize(ExpectedSize);
@@ -284,12 +285,13 @@ public:
       return C;
 
     // If reached, no such constant exists, create one.
+    // TODO(kschimpf) Don't get addresses of intrinsic function declarations.
     std::string Name;
-    unsigned FcnIDSize = FunctionIDValues.size();
+    unsigned FcnIDSize = FunctionDeclarationList.size();
     if (ID < FcnIDSize) {
-      Name = FunctionIDValues[ID]->getName();
-    } else if ((ID - FcnIDSize) < GlobalIDAddresses.size()) {
-      Name = GlobalIDAddresses[ID - FcnIDSize]->getName();
+      Name = FunctionDeclarationList[ID]->getName();
+    } else if ((ID - FcnIDSize) < VariableDeclarations.size()) {
+      Name = VariableDeclarations[ID - FcnIDSize]->getName();
     } else {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
@@ -304,47 +306,49 @@ public:
     return C;
   }
 
-  /// Returns the number of function addresses (i.e. ID's) defined in
-  /// the bitcode file.
+  /// Returns the number of function declarations in the bitcode file.
   unsigned getNumFunctionIDs() const { return NumFunctionIds; }
 
-  /// Returns the number of global IDs (function and global addresses)
-  /// defined in the bitcode file.
+  /// Returns the number of global declarations (i.e. IDs) defined in
+  /// the bitcode file.
   unsigned getNumGlobalIDs() const {
-    return FunctionIDValues.size() + GlobalIDAddresses.size();
+    return FunctionDeclarationList.size() + VariableDeclarations.size();
   }
 
-  /// Creates Count global addresses.
-  void CreateGlobalAddresses(size_t Count) {
-    assert(GlobalIDAddresses.empty());
+  /// Creates Count global variable declarations.
+  void CreateGlobalVariables(size_t Count) {
+    assert(VariableDeclarations.empty());
+    Ice::GlobalContext *Context = getTranslator().getContext();
     for (size_t i = 0; i < Count; ++i) {
-      GlobalIDAddresses.push_back(new Ice::GlobalAddress());
+      VariableDeclarations.push_back(Ice::VariableDeclaration::create(Context));
     }
   }
 
-  /// Returns the number of global addresses (i.e. ID's) defined in
-  /// the bitcode file.
-  Ice::SizeT getNumGlobalAddresses() const { return GlobalIDAddresses.size(); }
+  /// Returns the number of global variable declarations in the
+  /// bitcode file.
+  Ice::SizeT getNumGlobalVariables() const {
+    return VariableDeclarations.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 global variable declaration with the given index.
+  Ice::VariableDeclaration *getGlobalVariableByID(unsigned Index) {
+    if (Index < VariableDeclarations.size())
+      return VariableDeclarations[Index];
+    return reportGetGlobalVariableByIDError(Index);
+  }
+
+  /// Returns the global declaration (variable or function) with the
+  /// given Index.
+  Ice::GlobalDeclaration *getGlobalDeclarationByID(size_t Index) {
+    if (Index < NumFunctionIds)
+      return getFunctionByID(Index);
+    else
+      return getGlobalVariableByID(Index - NumFunctionIds);
   }
 
-  /// Returns the list of read global addresses.
-  const Ice::Translator::GlobalAddressList &getGlobalIDAddresses() {
-    return GlobalIDAddresses;
+  /// Returns the list of parsed global variable declarations.
+  const Ice::Translator::VariableDeclarationListType &getGlobalVariables() {
+    return VariableDeclarations;
   }
 
   /// Returns the corresponding ICE type for LLVMTy.
@@ -383,20 +387,21 @@ private:
   unsigned NumErrors;
   // The types associated with each type ID.
   std::vector<ExtendedType> TypeIDValues;
-  // 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.
+  // The set of functions.
+  FunctionDeclarationListType FunctionDeclarationList;
+  // The set of global variables.
+  Ice::Translator::VariableDeclarationListType VariableDeclarations;
+  // Relocatable constants associated with global declarations.
   std::vector<Ice::Constant *> ValueIDConstants;
-  // The number of function IDs.
+  // The number of function declarations (i.e. 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;
+  // The list of function declaration IDs (in the order found) that
+  // aren't just proto declarations.
+  // TODO(kschimpf): Instead of using this list, just use
+  // FunctionDeclarationList, and the isProto member function.
+  std::vector<unsigned> DefiningFunctionDeclarationsList;
   // Error recovery value to use when getFuncSigTypeByID fails.
   Ice::FuncSigType UndefinedFuncSigType;
 
@@ -423,6 +428,14 @@ private:
   void reportBadTypeIDAs(unsigned ID, const ExtendedType *Ty,
                          ExtendedType::TypeKind WantedType);
 
+  // Reports that there is no function declaration for ID. Returns an
+  // error recovery value to use.
+  Ice::FunctionDeclaration *reportGetFunctionByIDError(unsigned ID);
+
+  // Reports that there is not global variable declaration for
+  // ID. Returns an error recovery value to use.
+  Ice::VariableDeclaration *reportGetGlobalVariableByIDError(unsigned Index);
+
   // Reports that there is no corresponding ICE type for LLVMTy, and
   // returns ICE::IceType_void.
   Ice::Type convertToIceTypeError(Type *LLVMTy);
@@ -440,6 +453,34 @@ void TopLevelParser::reportBadTypeIDAs(unsigned ID, const ExtendedType *Ty,
   Error(StrBuf.str());
 }
 
+Ice::FunctionDeclaration *
+TopLevelParser::reportGetFunctionByIDError(unsigned ID) {
+  std::string Buffer;
+  raw_string_ostream StrBuf(Buffer);
+  StrBuf << "Function index " << ID
+         << " not allowed. Out of range. Must be less than "
+         << FunctionDeclarationList.size();
+  Error(StrBuf.str());
+  // TODO(kschimpf) Remove error recovery once implementation complete.
+  if (!FunctionDeclarationList.empty())
+    return FunctionDeclarationList[0];
+  report_fatal_error("Unable to continue");
+}
+
+Ice::VariableDeclaration *
+TopLevelParser::reportGetGlobalVariableByIDError(unsigned Index) {
+  std::string Buffer;
+  raw_string_ostream StrBuf(Buffer);
+  StrBuf << "Global index " << Index
+         << " not allowed. Out of range. Must be less than "
+         << VariableDeclarations.size();
+  Error(StrBuf.str());
+  // TODO(kschimpf) Remove error recovery once implementation complete.
+  if (!VariableDeclarations.empty())
+    return VariableDeclarations[0];
+  report_fatal_error("Unable to continue");
+}
+
 Ice::Type TopLevelParser::convertToIceTypeError(Type *LLVMTy) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
@@ -747,38 +788,40 @@ void TypesParser::ProcessRecord() {
   llvm_unreachable("Unknown type block record not processed!");
 }
 
-/// Parses the globals block (i.e. global variables).
+/// Parses the globals block (i.e. global variable declarations and
+/// corresponding initializers).
 class GlobalsParser : public BlockParserBaseClass {
 public:
   GlobalsParser(unsigned BlockID, BlockParserBaseClass *EnclosingParser)
       : BlockParserBaseClass(BlockID, EnclosingParser), InitializersNeeded(0),
-        NextGlobalID(0), CurrentAddress(&DummyAddress) {}
-
-  ~GlobalsParser() override {}
+        NextGlobalID(0), DummyGlobalVar(Ice::VariableDeclaration::create(
+                             getTranslator().getContext())),
+        CurGlobalVar(DummyGlobalVar) {}
 
 private:
   // Keeps track of how many initializers are expected for the global variable
-  // being built.
+  // declaration being built.
   unsigned InitializersNeeded;
 
-  // The index of the next global variable.
+  // The index of the next global variable declaration.
   unsigned NextGlobalID;
 
-  // Holds the current global address whose initializer is being defined.
-  Ice::GlobalAddress *CurrentAddress;
+  // Dummy global variable declaration to guarantee CurGlobalVar is
+  // always defined (allowing code to not need to check if
+  // CurGlobalVar is nullptr).
+  Ice::VariableDeclaration *DummyGlobalVar;
 
-  // Dummy global address to guarantee CurrentAddress is always defined
-  // (allowing code to not need to check if CurrentAddress is nullptr).
-  Ice::GlobalAddress DummyAddress;
+  // Holds the current global variable declaration being built.
+  Ice::VariableDeclaration *CurGlobalVar;
 
   void ExitBlock() override {
     verifyNoMissingInitializers();
-    unsigned NumIDs = Context->getNumGlobalAddresses();
+    unsigned NumIDs = Context->getNumGlobalVariables();
     if (NextGlobalID < NumIDs) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Globals block expects " << NumIDs
-             << " global definitions. Found: " << NextGlobalID;
+             << " global variable declarations. Found: " << NextGlobalID;
       Error(StrBuf.str());
     }
     BlockParserBaseClass::ExitBlock();
@@ -786,12 +829,12 @@ private:
 
   void ProcessRecord() override;
 
-  // Checks if the number of initializers for the CurrentAddress is the same as
+  // Checks if the number of initializers for the CurGlobalVar 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() {
-    size_t NumInits = CurrentAddress->getInitializers().size();
+    size_t NumInits = CurGlobalVar->getInitializers().size();
     if (InitializersNeeded != NumInits) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
@@ -801,6 +844,7 @@ private:
         StrBuf << "s";
       StrBuf << ". Found: " << NumInits;
       Error(StrBuf.str());
+      InitializersNeeded = NumInits;
     }
   }
 };
@@ -812,11 +856,11 @@ void GlobalsParser::ProcessRecord() {
     // COUNT: [n]
     if (!isValidRecordSize(1, "Globals count"))
       return;
-    if (NextGlobalID != Context->getNumGlobalAddresses()) {
+    if (NextGlobalID != Context->getNumGlobalVariables()) {
       Error("Globals count record not first in block.");
       return;
     }
-    Context->CreateGlobalAddresses(Values[0]);
+    Context->CreateGlobalVariables(Values[0]);
     return;
   case naclbitc::GLOBALVAR_VAR: {
     // VAR: [align, isconst]
@@ -824,9 +868,9 @@ void GlobalsParser::ProcessRecord() {
       return;
     verifyNoMissingInitializers();
     InitializersNeeded = 1;
-    CurrentAddress = Context->getGlobalAddress(NextGlobalID);
-    CurrentAddress->setAlignment((1 << Values[0]) >> 1);
-    CurrentAddress->setIsConstant(Values[1] != 0);
+    CurGlobalVar = Context->getGlobalVariableByID(NextGlobalID);
+    CurGlobalVar->setAlignment((1 << Values[0]) >> 1);
+    CurGlobalVar->setIsConstant(Values[1] != 0);
     ++NextGlobalID;
     return;
   }
@@ -834,7 +878,7 @@ void GlobalsParser::ProcessRecord() {
     // COMPOUND: [size]
     if (!isValidRecordSize(1, "globals compound"))
       return;
-    if (!CurrentAddress->getInitializers().empty()) {
+    if (!CurGlobalVar->getInitializers().empty()) {
       Error("Globals compound record not first initializer");
       return;
     }
@@ -851,17 +895,17 @@ void GlobalsParser::ProcessRecord() {
     // ZEROFILL: [size]
     if (!isValidRecordSize(1, "Globals zerofill"))
       return;
-    CurrentAddress->addInitializer(
-        new Ice::GlobalAddress::ZeroInitializer(Values[0]));
-    break;
+    CurGlobalVar->addInitializer(
+        new Ice::VariableDeclaration::ZeroInitializer(Values[0]));
+    return;
   }
   case naclbitc::GLOBALVAR_DATA: {
     // DATA: [b0, b1, ...]
     if (!isValidRecordSizeAtLeast(1, "Globals data"))
       return;
-    CurrentAddress->addInitializer(
-        new Ice::GlobalAddress::DataInitializer(Values));
-    break;
+    CurGlobalVar->addInitializer(
+        new Ice::VariableDeclaration::DataInitializer(Values));
+    return;
   }
   case naclbitc::GLOBALVAR_RELOC: {
     // RELOC: [val, [addend]]
@@ -871,19 +915,9 @@ void GlobalsParser::ProcessRecord() {
     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));
-    }
-    break;
+    CurGlobalVar->addInitializer(new Ice::VariableDeclaration::RelocInitializer(
+        Context->getGlobalDeclarationByID(Index), Offset));
+    return;
   }
   default:
     BlockParserBaseClass::ProcessRecord();
@@ -964,23 +998,25 @@ public:
       : BlockParserBaseClass(BlockID, EnclosingParser),
         Func(new Ice::Cfg(getTranslator().getContext())), CurrentBbIndex(0),
         FcnId(Context->getNextFunctionBlockValueID()),
-        LLVMFunc(Context->getFunctionByID(FcnId)),
+        FuncDecl(Context->getFunctionByID(FcnId)),
         CachedNumGlobalValueIDs(Context->getNumGlobalIDs()),
         NextLocalInstIndex(Context->getNumGlobalIDs()),
         InstIsTerminating(false) {
-    Func->setFunctionName(LLVMFunc->getName());
+    Func->setFunctionName(FuncDecl->getName());
     if (getFlags().TimeEachFunction)
       getTranslator().getContext()->pushTimer(
           getTranslator().getContext()->getTimerID(
               Ice::GlobalContext::TSK_Funcs, Func->getFunctionName()),
           Ice::GlobalContext::TSK_Funcs);
-    Func->setReturnType(Context->convertToIceType(LLVMFunc->getReturnType()));
-    Func->setInternal(LLVMFunc->hasInternalLinkage());
+    // TODO(kschimpf) Clean up API to add a function signature to
+    // a CFG.
+    const Ice::FuncSigType &Signature = FuncDecl->getSignature();
+    Func->setReturnType(Signature.getReturnType());
+    Func->setInternal(FuncDecl->getLinkage() == GlobalValue::InternalLinkage);
     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())));
+    for (Ice::Type ArgType : Signature.getArgList()) {
+      Func->addArg(getNextInstVar(ArgType));
     }
   }
 
@@ -1000,8 +1036,8 @@ private:
   Ice::CfgNode *CurrentNode;
   // The ID for the function.
   unsigned FcnId;
-  // The corresponding LLVM function.
-  Function *LLVMFunc;
+  // The corresponding function declaration.
+  Ice::FunctionDeclaration *FuncDecl;
   // Holds the dividing point between local and global absolute value indices.
   uint32_t CachedNumGlobalValueIDs;
   // Holds operands local to the function block, based on indices
@@ -1999,12 +2035,12 @@ void FunctionParser::ProcessRecord() {
     // CALL_INDIRECT: [cc, fn, returnty, args...]
     //
     // Note: The difference between CALL and CALL_INDIRECT is that
-    // CALL has an explicit function address, while the CALL_INDIRECT
-    // is just an address. For CALL, we can infer the return type by
-    // looking up the type signature associated with the function
-    // address. For CALL_INDIRECT we can only infer the type signature
-    // via argument types, and the corresponding return type stored in
-    // CALL_INDIRECT record.
+    // CALL has a reference to an explicit function declaration, while
+    // the CALL_INDIRECT is just an address. For CALL, we can infer
+    // the return type by looking up the type signature associated
+    // with the function declaration. For CALL_INDIRECT we can only
+    // infer the type signature via argument types, and the
+    // corresponding return type stored in CALL_INDIRECT record.
     Ice::SizeT ParamsStartIndex = 2;
     if (Record.GetCode() == naclbitc::FUNC_CODE_INST_CALL) {
       if (!isValidRecordSizeAtLeast(2, "function block call"))
@@ -2034,17 +2070,9 @@ void FunctionParser::ProcessRecord() {
     Ice::Type ReturnType = Ice::IceType_void;
     const Ice::Intrinsics::FullIntrinsicInfo *IntrinsicInfo = nullptr;
     if (Record.GetCode() == naclbitc::FUNC_CODE_INST_CALL) {
-      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());
+      Ice::FunctionDeclaration *Fcn = Context->getFunctionByID(CalleeIndex);
+      const Ice::FuncSigType &Signature = Fcn->getSignature();
+      ReturnType = Signature.getReturnType();
 
       // Check if this direct call is to an Intrinsic (starts with "llvm.")
       static Ice::IceString LLVMPrefix("llvm.");
@@ -2339,45 +2367,60 @@ class ModuleParser : public BlockParserBaseClass {
 public:
   ModuleParser(unsigned BlockID, TopLevelParser *Context)
       : BlockParserBaseClass(BlockID, Context),
-        GlobalAddressNamesAndInitializersInstalled(false) {}
+        GlobalDeclarationNamesAndInitializersInstalled(false) {}
 
   ~ModuleParser() override {}
 
 private:
-  // True if we have already instaledl names for unnamed global addresses,
-  // and generated global constant initializers.
-  bool GlobalAddressNamesAndInitializersInstalled;
-
-  // 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.
-  void InstallGlobalAddressNamesAndInitializers() {
-    if (!GlobalAddressNamesAndInitializersInstalled) {
+  // True if we have already installed names for unnamed global declarations,
+  // and have generated global constant initializers.
+  bool GlobalDeclarationNamesAndInitializersInstalled;
+
+  // Generates names for unnamed global addresses (i.e. functions and
+  // global variables). Then lowers global variable declaration
+  // initializers to the target. May be called multiple times. Only
+  // the first call will do the installation.
+  void InstallGlobalNamesAndGlobalVarInitializers() {
+    if (!GlobalDeclarationNamesAndInitializersInstalled) {
       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());
-          }
+        for (Ice::VariableDeclaration *Var : Context->getGlobalVariables()) {
+          installDeclarationName(Trans, Var, GlobalPrefix, "global", NameIndex);
+        }
+      }
+      const Ice::IceString &FunctionPrefix = getFlags().DefaultFunctionPrefix;
+      if (!FunctionPrefix.empty()) {
+        uint32_t NameIndex = 0;
+        for (Ice::FunctionDeclaration *Func :
+             Context->getFunctionDeclarationList()) {
+          installDeclarationName(Trans, Func, FunctionPrefix, "function",
+                                 NameIndex);
         }
       }
-      Trans.nameUnnamedFunctions(Context->getModule());
-      getTranslator().lowerGlobals(Context->getGlobalIDAddresses());
-      GlobalAddressNamesAndInitializersInstalled = true;
+      getTranslator().lowerGlobals(Context->getGlobalVariables());
+      GlobalDeclarationNamesAndInitializersInstalled = true;
+    }
+  }
+
+  void installDeclarationName(Ice::Translator &Trans,
+                              Ice::GlobalDeclaration *Decl,
+                              const Ice::IceString &Prefix, const char *Context,
+                              uint32_t &NameIndex) {
+    if (!Decl->hasName()) {
+      Decl->setName(Trans.createUnnamedName(Prefix, NameIndex));
+      ++NameIndex;
+    } else {
+      Trans.checkIfUnnamedNameSafe(Decl->getName(), Context, Prefix,
+                                   Trans.getContext()->getStrDump());
     }
   }
 
   bool ParseBlock(unsigned BlockID) override;
 
   void ExitBlock() override {
-    InstallGlobalAddressNamesAndInitializers();
+    InstallGlobalNamesAndGlobalVarInitializers();
     getTranslator().emitConstants();
   }
 
@@ -2400,26 +2443,8 @@ private:
 };
 
 void ModuleValuesymtabParser::setValueName(uint64_t Index, StringType &Name) {
-  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;
-  }
-
-  std::string Buffer;
-  raw_string_ostream StrBuf(Buffer);
-  StrBuf << "Invalid global address ID in valuesymtab: " << Index;
-  Error(StrBuf.str());
-  return;
+  Context->getGlobalDeclarationByID(Index)
+      ->setName(StringRef(Name.data(), Name.size()));
 }
 
 void ModuleValuesymtabParser::setBbName(uint64_t Index, StringType &Name) {
@@ -2447,7 +2472,7 @@ bool ModuleParser::ParseBlock(unsigned BlockID) {
     return Parser.ParseThisBlock();
   }
   case naclbitc::FUNCTION_BLOCK_ID: {
-    InstallGlobalAddressNamesAndInitializers();
+    InstallGlobalNamesAndGlobalVarInitializers();
     FunctionParser Parser(BlockID, this);
     return Parser.ParseThisBlock();
   }
@@ -2476,7 +2501,7 @@ void ModuleParser::ProcessRecord() {
     // FUNCTION:  [type, callingconv, isproto, linkage]
     if (!isValidRecordSize(4, "Function heading"))
       return;
-    const Ice::FuncSigType &Ty = Context->getFuncSigTypeByID(Values[0]);
+    const Ice::FuncSigType &Signature = Context->getFuncSigTypeByID(Values[0]);
     CallingConv::ID CallingConv;
     if (!naclbitc::DecodeCallingConv(Values[1], CallingConv)) {
       std::string Buffer;
@@ -2494,19 +2519,12 @@ void ModuleParser::ProcessRecord() {
       Error(StrBuf.str());
       return;
     }
-    SmallVector<Type *, 8> ArgTys;
-    for (Ice::Type ArgType : Ty.getArgList()) {
-      ArgTys.push_back(Context->convertToLLVMType(ArgType));
-    }
-    Function *Func = Function::Create(
-        FunctionType::get(Context->convertToLLVMType(Ty.getReturnType()),
-                          ArgTys, false),
-        Linkage, "", Context->getModule());
-    Func->setCallingConv(CallingConv);
+    Ice::FunctionDeclaration *Func = Ice::FunctionDeclaration::create(
+        getTranslator().getContext(), Signature, CallingConv, Linkage,
+        Values[2] == 0);
     if (Values[2] == 0)
       Context->setNextValueIDAsImplementedFunction();
     Context->setNextFunctionID(Func);
-    // TODO(kschimpf) verify if Func matches PNaCl ABI.
     return;
   }
   default:

tests_lit/llvm2ice_tests/globalrelocs.ll

+; Tests if we handle global variables with relocation initializers.
+
+; Test that we handle it in the ICE converter.
+; RUN: %lc2i -i %s --args -verbose inst | FileCheck %s
+
+; Test that we handle it using Subzero's bitcode reader.
+; RUN: %p2i -i %s --args -verbose inst | FileCheck %s
+
+@bytes = internal global [7 x i8] c"abcdefg"
+; CHECK: @bytes = internal global [7 x i8] c"abcdefg"
+; CHECK:	.type	bytes,@object
+; CHECK:	.section	.data,"aw",@progbits
+; CHECK:bytes:
+; CHECK:	.byte	97
+; CHECK:	.byte	98
+; CHECK:	.byte	99
+; CHECK:	.byte	100
+; CHECK:	.byte	101
+; CHECK:	.byte	102
+; CHECK:	.byte	103
+; CHECK:	.size	bytes, 7
+
+@const_bytes = internal constant [7 x i8] c"abcdefg"
+; CHECK: @const_bytes = internal constant [7 x i8] c"abcdefg"
+; CHECK:	.type	const_bytes,@object
+; CHECK:	.section	.rodata,"a",@progbits
+; CHECK:const_bytes:
+; CHECK:	.byte	97
+; CHECK:	.byte	98
+; CHECK:	.byte	99
+; CHECK:	.byte	100
+; CHECK:	.byte	101
+; CHECK:	.byte	102
+; CHECK:	.byte	103
+; CHECK:	.size	const_bytes, 7
+
+@ptr_to_ptr = internal global i32 ptrtoint (i32* @ptr to i32)
+; CHECK: @ptr_to_ptr = internal global i32 ptrtoint (i32* @ptr to i32)
+; CHECK:	.type	ptr_to_ptr,@object
+; CHECK:	.section	.data,"aw",@progbits
+; CHECK:ptr_to_ptr:
+; CHECK:	.long	ptr
+; CHECK:	.size	ptr_to_ptr, 4
+
+@const_ptr_to_ptr = internal constant i32 ptrtoint (i32* @ptr to i32)
+; CHECK: @const_ptr_to_ptr = internal constant i32 ptrtoint (i32* @ptr to i32)
+; CHECK:	.type	const_ptr_to_ptr,@object
+; CHECK:	.section	.rodata,"a",@progbits
+; CHECK:const_ptr_to_ptr:
+; CHECK:	.long	ptr
+; CHECK:	.size	const_ptr_to_ptr, 4
+
+@ptr_to_func = internal global i32 ptrtoint (void ()* @func to i32)
+; CHECK: @ptr_to_func = internal global i32 ptrtoint (void ()* @func to i32)
+; CHECK:	.type	ptr_to_func,@object
+; CHECK:	.section	.data,"aw",@progbits
+; CHECK:ptr_to_func:
+; CHECK:	.long	func
+; CHECK:	.size	ptr_to_func, 4
+
+@const_ptr_to_func = internal constant i32 ptrtoint (void ()* @func to i32)
+; CHECK: @const_ptr_to_func = internal constant i32 ptrtoint (void ()* @func to i32)
+; CHECK:	.type	const_ptr_to_func,@object
+; CHECK:	.section	.rodata,"a",@progbits
+; CHECK:const_ptr_to_func:
+; CHECK:	.long	func
+; CHECK:	.size	const_ptr_to_func, 4
+
+@compound = internal global <{ [3 x i8], i32 }> <{ [3 x i8] c"foo", i32 ptrtoint (void ()* @func to i32) }>
+; CHECK: @compound = internal global <{ [3 x i8], i32 }> <{ [3 x i8] c"foo", i32 ptrtoint (void ()* @func to i32) }>
+; CHECK:	.type	compound,@object
+; CHECK:	.section	.data,"aw",@progbits
+; CHECK:compound:
+; CHECK:	.byte	102
+; CHECK:	.byte	111
+; CHECK:	.byte	111
+; CHECK:	.long	func
+; CHECK:	.size	compound, 7
+
+@const_compound = internal constant <{ [3 x i8], i32 }> <{ [3 x i8] c"foo", i32 ptrtoint (void ()* @func to i32) }>
+; CHECK: @const_compound = internal constant <{ [3 x i8], i32 }> <{ [3 x i8] c"foo", i32 ptrtoint (void ()* @func to i32) }>
+; CHECK:	.type	const_compound,@object
+; CHECK:	.section	.rodata,"a",@progbits
+; CHECK:const_compound:
+; CHECK:	.byte	102
+; CHECK:	.byte	111
+; CHECK:	.byte	111
+; CHECK:	.long	func
+; CHECK:	.size	const_compound, 7
+
+@ptr = internal global i32 ptrtoint ([7 x i8]* @bytes to i32)
+; CHECK: @ptr = internal global i32 ptrtoint ([7 x i8]* @bytes to i32)
+; CHECK:	.type	ptr,@object
+; CHECK:	.section	.data,"aw",@progbits
+; CHECK:ptr:
+; CHECK:	.long	bytes
+; CHECK:	.size	ptr, 4
+
+@const_ptr = internal constant i32 ptrtoint ([7 x i8]* @bytes to i32)
+; CHECK: @const_ptr = internal constant i32 ptrtoint ([7 x i8]* @bytes to i32)
+; CHECK:	.type	const_ptr,@object
+; CHECK:	.section	.rodata,"a",@progbits
+; CHECK:const_ptr:
+; CHECK:	.long	bytes
+; CHECK:	.size	const_ptr, 4
+
+@addend_ptr = internal global i32 add (i32 ptrtoint (i32* @ptr to i32), i32 1)
+; CHECK: @addend_ptr = internal global i32 add (i32 ptrtoint (i32* @ptr to i32), i32 1)
+; CHECK:	.type	addend_ptr,@object
+; CHECK:	.section	.data,"aw",@progbits
+; CHECK:addend_ptr:
+; CHECK:	.long	ptr + 1
+; CHECK:	.size	addend_ptr, 4
+
+@const_addend_ptr = internal constant i32 add (i32 ptrtoint (i32* @ptr to i32), i32 1)
+; CHECK: @const_addend_ptr = internal constant i32 add (i32 ptrtoint (i32* @ptr to i32), i32 1)
+; CHECK:	.type	const_addend_ptr,@object
+; CHECK:	.section	.rodata,"a",@progbits
+; CHECK:const_addend_ptr:
+; CHECK:	.long	ptr + 1
+; CHECK:	.size	const_addend_ptr, 4
+
+@addend_negative = internal global i32 add (i32 ptrtoint (i32* @ptr to i32), i32 -1)
+; CHECK: @addend_negative = internal global i32 add (i32 ptrtoint (i32* @ptr to i32), i32 -1)
+; CHECK:	.type	addend_negative,@object
+; CHECK:	.section	.data,"aw",@progbits
+; CHECK:addend_negative:
+; CHECK:	.long	ptr - 1
+; CHECK:	.size	addend_negative, 4
+
+@const_addend_negative = internal constant i32 add (i32 ptrtoint (i32* @ptr to i32), i32 -1)
+; CHECK: @const_addend_negative = internal constant i32 add (i32 ptrtoint (i32* @ptr to i32), i32 -1)
+; CHECK:	.type	const_addend_negative,@object
+; CHECK:	.section	.rodata,"a",@progbits
+; CHECK:const_addend_negative:
+; CHECK:	.long	ptr - 1
+; CHECK:	.size	const_addend_negative, 4
+
+@addend_array1 = internal global i32 add (i32 ptrtoint ([7 x i8]* @bytes to i32), i32 1)
+; CHECK: @addend_array1 = internal global i32 add (i32 ptrtoint ([7 x i8]* @bytes to i32), i32 1)
+; CHECK:	.type	addend_array1,@object
+; CHECK:	.section	.data,"aw",@progbits
+; CHECK:addend_array1:
+; CHECK:	.long	bytes + 1
+; CHECK:	.size	addend_array1, 4
+
+@const_addend_array1 = internal constant i32 add (i32 ptrtoint ([7 x i8]* @bytes to i32), i32 1)
+; CHECK: @const_addend_array1 = internal constant i32 add (i32 ptrtoint ([7 x i8]* @bytes to i32), i32 1)
+; CHECK:	.type	const_addend_array1,@object
+; CHECK:	.section	.rodata,"a",@progbits
+; CHECK:const_addend_array1:
+; CHECK:	.long	bytes + 1
+; CHECK:	.size	const_addend_array1, 4
+
+@addend_array2 = internal global i32 add (i32 ptrtoint ([7 x i8]* @bytes to i32), i32 7)
+; CHECK: @addend_array2 = internal global i32 add (i32 ptrtoint ([7 x i8]* @bytes to i32), i32 7)
+; CHECK:	.type	addend_array2,@object
+; CHECK:	.section	.data,"aw",@progbits
+; CHECK:addend_array2:
+; CHECK:	.long	bytes + 7
+; CHECK:	.size	addend_array2, 4
+
+@const_addend_array2 = internal constant i32 add (i32 ptrtoint ([7 x i8]* @bytes to i32), i32 7)
+; CHECK: @const_addend_array2 = internal constant i32 add (i32 ptrtoint ([7 x i8]* @bytes to i32), i32 7)
+; CHECK:	.type	const_addend_array2,@object
+; CHECK:	.section	.rodata,"a",@progbits
+; CHECK:const_addend_array2:
+; CHECK:	.long	bytes + 7
+; CHECK:	.size	const_addend_array2, 4
+
+@addend_array3 = internal global i32 add (i32 ptrtoint ([7 x i8]* @bytes to i32), i32 9)
+; CHECK: @addend_array3 = internal global i32 add (i32 ptrtoint ([7 x i8]* @bytes to i32), i32 9)
+; CHECK:	.type	addend_array3,@object
+; CHECK:	.section	.data,"aw",@progbits
+; CHECK:addend_array3:
+; CHECK:	.long	bytes + 9
+; CHECK:	.size	addend_array3, 4
+
+@const_addend_array3 = internal constant i32 add (i32 ptrtoint ([7 x i8]* @bytes to i32), i32 9)
+; CHECK: @const_addend_array3 = internal constant i32 add (i32 ptrtoint ([7 x i8]* @bytes to i32), i32 9)
+; CHECK:	.type	const_addend_array3,@object
+; CHECK:	.section	.rodata,"a",@progbits
+; CHECK:const_addend_array3:
+; CHECK:	.long	bytes + 9
+; CHECK:	.size	const_addend_array3, 4
+
+@addend_struct1 = internal global i32 add (i32 ptrtoint (<{ [3 x i8], i32 }>* @compound to i32), i32 1)
+; CHECK: @addend_struct1 = internal global i32 add (i32 ptrtoint (<{ [3 x i8], i32 }>* @compound to i32), i32 1)
+; CHECK:	.type	addend_struct1,@object
+; CHECK:	.section	.data,"aw",@progbits
+; CHECK:addend_struct1:
+; CHECK:	.long	compound + 1
+; CHECK:	.size	addend_struct1, 4
+
+@const_addend_struct1 = internal constant i32 add (i32 ptrtoint (<{ [3 x i8], i32 }>* @compound to i32), i32 1)
+; CHECK: @const_addend_struct1 = internal constant i32 add (i32 ptrtoint (<{ [3 x i8], i32 }>* @compound to i32), i32 1)
+; CHECK:	.type	const_addend_struct1,@object
+; CHECK:	.section	.rodata,"a",@progbits
+; CHECK:const_addend_struct1:
+; CHECK:	.long	compound + 1
+; CHECK:	.size	const_addend_struct1, 4
+
+@addend_struct2 = internal global i32 add (i32 ptrtoint (<{ [3 x i8], i32 }>* @compound to i32), i32 4)
+; CHECK: @addend_struct2 = internal global i32 add (i32 ptrtoint (<{ [3 x i8], i32 }>* @compound to i32), i32 4)
+; CHECK:	.type	addend_struct2,@object
+; CHECK:	.section	.data,"aw",@progbits
+; CHECK:addend_struct2:
+; CHECK:	.long	compound + 4
+; CHECK:	.size	addend_struct2, 4
+
+@const_addend_struct2 = internal constant i32 add (i32 ptrtoint (<{ [3 x i8], i32 }>* @compound to i32), i32 4)
+; CHECK: @const_addend_struct2 = internal constant i32 add (i32 ptrtoint (<{ [3 x i8], i32 }>* @compound to i32), i32 4)
+; CHECK:	.type	const_addend_struct2,@object
+; CHECK:	.section	.rodata,"a",@progbits
+; CHECK:const_addend_struct2:
+; CHECK:	.long	compound + 4
+; CHECK:	.size	const_addend_struct2, 4
+
+@ptr_to_func_align = internal global i32 ptrtoint (void ()* @func to i32), align 8
+; CHECK: @ptr_to_func_align = internal global i32 ptrtoint (void ()* @func to i32), align 8
+; CHECK:	.type	ptr_to_func_align,@object
+; CHECK:	.section	.data,"aw",@progbits
+; CHECK:	.align	8
+; CHECK:ptr_to_func_align:
+; CHECK:	.long	func
+; CHECK:	.size	ptr_to_func_align, 4
+
+@const_ptr_to_func_align = internal constant i32 ptrtoint (void ()* @func to i32), align 8
+; CHECK: @const_ptr_to_func_align = internal constant i32 ptrtoint (void ()* @func to i32), align 8
+; CHECK:	.type	const_ptr_to_func_align,@object
+; CHECK:	.section	.rodata,"a",@progbits
+; CHECK:	.align	8
+; CHECK:const_ptr_to_func_align:
+; CHECK:	.long	func
+; CHECK:	.size	const_ptr_to_func_align, 4
+
+@char = internal constant [1 x i8] c"0"
+; CHECK: @char = internal constant [1 x i8] c"0"
+; CHECK:	.type	char,@object
+; CHECK:	.section	.rodata,"a",@progbits
+; CHECK:char:
+; CHECK:	.byte	48
+; CHECK:	.size	char, 1
+
+@short = internal constant [2 x i8] zeroinitializer
+; CHECK: @short = internal constant [2 x i8] zeroinitializer
+; CHECK:	.type	short,@object
+; CHECK:	.section	.rodata,"a",@progbits
+; CHECK:short:
+; CHECK:	.zero	2
+; CHECK:	.size	short, 2
+
+define void @func() {
+  ret void
+}
+
+; CHECK: define void @func() {
+

tests_lit/reader_tests/globalinit.pnacl.ll

 ; Test of global initializers.
 
 ; Check that we generate proper global initializers.
-; RUN: %p2i -i %s --args -verbose inst | FileCheck %s
-
-; Check that what we generate is valid assembly
-; RUN: %p2i -i %s --args -verbose none \
-; RUN:     | llvm-mc -triple=i686-none-nacl -x86-asm-syntax=intel -filetype=obj
-
-; Check that we don't generate errors
-; RUN: %p2i -i %s --args -verbose none | FileCheck --check-prefix=ERRORS %s
+; RUN: %l2i -i %s --insts | FileCheck %s
+; RUN: %p2i -i %s --insts | FileCheck %s
 
 @PrimitiveInit = internal global [4 x i8] c"\1B\00\00\00", align 4
-; CHECK: .type PrimitiveInit,@object
-; CHECK-NEXT: .section .data,"aw",@progbits
-; CHECK-NEXT: .align 4
-; CHECK-NEXT: PrimitiveInit:
-; CHECK-NEXT: .byte
-; CHECK: .size PrimitiveInit, 4
+; CHECK: @PrimitiveInit = internal global [4 x i8] c"\1B\00\00\00", align 4
 
 @PrimitiveInitConst = internal constant [4 x i8] c"\0D\00\00\00", align 4
-; CHECK: .type PrimitiveInitConst,@object
-; CHECK-NEXT: .section .rodata,"a",@progbits
-; CHECK-NEXT: .align 4
-; CHECK-NEXT: PrimitiveInitConst:
-; CHECK-NEXT: .byte
-; CHECK: .size PrimitiveInitConst, 4
+; CHECK-NEXT: @PrimitiveInitConst = internal constant [4 x i8] c"\0D\00\00\00", align 4
 
 @ArrayInit = internal global [20 x i8] c"\0A\00\00\00\14\00\00\00\1E\00\00\00(\00\00\002\00\00\00", align 4
-; CHECK: .type ArrayInit,@object
-; CHECK-NEXT: .section .data,"aw",@progbits
-; CHECK-NEXT: .align 4
-; CHECK-NEXT: ArrayInit:
-; CHECK-NEXT: .byte
-; CHECK: .size ArrayInit, 20
+; CHECK-NEXT: @ArrayInit = internal global [20 x i8] c"\0A\00\00\00\14\00\00\00\1E\00\00\00(\00\00\002\00\00\00", align 4
 
 @ArrayInitPartial = internal global [40 x i8] c"<\00\00\00F\00\00\00P\00\00\00Z\00\00\00d\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", align 4
-; CHECK: .type ArrayInitPartial,@object
-; CHECK-NEXT: .section .data,"aw",@progbits
-; CHECK-NEXT: .align 4
-; CHECK-NEXT: ArrayInitPartial:
-; CHECK-NEXT: .byte
-; CHECK: .size ArrayInitPartial, 40
+; CHECK-NEXT: @ArrayInitPartial = internal global [40 x i8] c"<\00\00\00F\00\00\00P\00\00\00Z\00\00\00d\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", align 4
 
 @PrimitiveInitStatic = internal global [4 x i8] zeroinitializer, align 4
-; CHECK: .type PrimitiveInitStatic,@object
-; CHECK-NEXT: .local PrimitiveInitStatic
-; CHECK-NEXT: .comm PrimitiveInitStatic,4,4
+; CHECK-NEXT: @PrimitiveInitStatic = internal global [4 x i8] zeroinitializer, align 4
 
 @PrimitiveUninit = internal global [4 x i8] zeroinitializer, align 4
-; CHECK: .type PrimitiveUninit,@object
-; CHECK-NEXT: .local PrimitiveUninit
-; CHECK-NEXT: .comm PrimitiveUninit,4,4
+; CHECK-NEXT: @PrimitiveUninit = internal global [4 x i8] zeroinitializer, align 4
 
 @ArrayUninit = internal global [20 x i8] zeroinitializer, align 4
-; CHECK: .type ArrayUninit,@object
-; CHECK-NEXT: .local ArrayUninit
-; CHECK-NEXT: .comm ArrayUninit,20,4
+; CHECK-NEXT: @ArrayUninit = internal global [20 x i8] zeroinitializer, align 4
 
 @ArrayUninitConstDouble = internal constant [200 x i8] zeroinitializer, align 8
-; CHECK: .type ArrayUninitConstDouble,@object
-; CHECK-NEXT: .section .rodata,"a",@progbits
-; CHECK-NEXT: .align 8
-; CHECK-NEXT: ArrayUninitConstDouble:
-; CHECK-NEXT: .zero 200
-; CHECK-NEXT: .size ArrayUninitConstDouble, 200
+; CHECK-NEXT: @ArrayUninitConstDouble = internal constant [200 x i8] zeroinitializer, align 8
 
 @ArrayUninitConstInt = internal constant [20 x i8] zeroinitializer, align 4
-; CHECK: .type ArrayUninitConstInt,@object
-; CHECK: .section .rodata,"a",@progbits
-; CHECK-NEXT: .align 4
-; CHECK-NEXT: ArrayUninitConstInt:
-; CHECK-NEXT: .zero 20
-; CHECK-NEXT: .size ArrayUninitConstInt, 20
+; CHECK-NEXT: @ArrayUninitConstInt = internal constant [20 x i8] zeroinitializer, align 4
 
 @__init_array_start = internal constant [0 x i8] zeroinitializer, align 4
+; CHECK-NEXT: @__init_array_start = internal constant [0 x i8] zeroinitializer, align 4
+
 @__fini_array_start = internal constant [0 x i8] zeroinitializer, align 4
+; CHECK: @__fini_array_start = internal constant [0 x i8] zeroinitializer, align 4
+
 @__tls_template_start = internal constant [0 x i8] zeroinitializer, align 8
+; CHECK: @__tls_template_start = internal constant [0 x i8] zeroinitializer, align 8
+
 @__tls_template_alignment = internal constant [4 x i8] c"\01\00\00\00", align 4
+; CHECK: @__tls_template_alignment = internal constant [4 x i8] c"\01\00\00\00", align 4
 
 define internal i32 @main(i32 %argc, i32 %argv) {
 entry:
@@ -96,28 +61,6 @@ entry:
   call void @use(i32 %expanded13)
   ret i32 0
 }
-; CHECK-LABEL: main
-; CHECK: .att_syntax
-; CHECK: leal PrimitiveInit,
-; CHECK: .intel_syntax
-; CHECK: .att_syntax
-; CHECK: leal PrimitiveInitConst,
-; CHECK: .intel_syntax
-; CHECK: .att_syntax
-; CHECK: leal PrimitiveInitStatic,
-; CHECK: .intel_syntax
-; CHECK: .att_syntax
-; CHECK: leal PrimitiveUninit,
-; CHECK: .intel_syntax
-; CHECK: .att_syntax
-; CHECK: leal ArrayInit,
-; CHECK: .intel_syntax
-; CHECK: .att_syntax
-; CHECK: leal ArrayInitPartial,
-; CHECK: .intel_syntax
-; CHECK: .att_syntax
-; CHECK: leal ArrayUninit,
-; CHECK: .intel_syntax
 
 declare void @use(i32)