Write out global initializers and data rel directly to ELF file.

src/IceConverter.cpp

 //===- subzero/src/IceConverter.cpp - Converts LLVM to Ice  ---------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the LLVM to ICE converter.
@@ skipping 625 matching lines @@
   LLVM2ICEGlobalsConverter &
   operator-(const LLVM2ICEGlobalsConverter &) = delete;
 
 public:
   LLVM2ICEGlobalsConverter(Ice::Converter &Converter)
       : LLVM2ICEConverter(Converter) {}
 
   /// 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);
+  void convertGlobalsToIce(Module *Mod,
+                           Ice::VariableDeclarationList &VariableDeclarations);
 
 private:
   // 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::RelocOffsetT Offset = 0;
     addGlobalInitializer(Global, Initializer, HasOffset, Offset);
   }
@@ skipping 15 matching lines @@
 
     std::string Buffer;
     raw_string_ostream StrBuf(Buffer);
     StrBuf << "Constant not i32 literal: " << *C;
     report_fatal_error(StrBuf.str());
     return 0;
   }
 };
 
 void LLVM2ICEGlobalsConverter::convertGlobalsToIce(
-    Module *Mod,
-    Ice::Translator::VariableDeclarationListType &VariableDeclarations) {
+    Module *Mod, Ice::VariableDeclarationList &VariableDeclarations) {
   for (Module::const_global_iterator I = Mod->global_begin(),
                                      E = Mod->global_end();
        I != E; ++I) {
 
     const GlobalVariable *GV = I;
 
     Ice::GlobalDeclaration *Var = getConverter().getGlobalDeclaration(GV);
     Ice::VariableDeclaration* VarDecl = cast<Ice::VariableDeclaration>(Var);
     VariableDeclarations.push_back(VarDecl);
 
@@ skipping 165 matching lines @@
     Var->setName(GV->getName());
     Var->setAlignment(GV->getAlignment());
     Var->setIsConstant(GV->isConstant());
     Var->setLinkage(GV->getLinkage());
     GlobalDeclarationMap[GV] = Var;
   }
 }
 
 void Converter::convertGlobals(Module *Mod) {
   LLVM2ICEGlobalsConverter GlobalsConverter(*this);
-  Translator::VariableDeclarationListType VariableDeclarations;
+  VariableDeclarationList VariableDeclarations;
   GlobalsConverter.convertGlobalsToIce(Mod, VariableDeclarations);
   lowerGlobals(VariableDeclarations);
 }
 
 void Converter::convertFunctions() {
   TimerStackIdT StackID = GlobalContext::TSK_Funcs;
   for (const Function &I : *Mod) {
     if (I.empty())
       continue;
 
     TimerIdT TimerID = 0;
     if (ALLOW_DUMP && Ctx->getFlags().TimeEachFunction) {
       TimerID = Ctx->getTimerID(StackID, I.getName());
       Ctx->pushTimer(TimerID, StackID);
     }
     LLVM2ICEFunctionConverter FunctionConverter(*this);
 
     Cfg *Fcn = FunctionConverter.convertFunction(&I);
     translateFcn(Fcn);
     if (ALLOW_DUMP && Ctx->getFlags().TimeEachFunction)
       Ctx->popTimer(TimerID, StackID);
   }
 
   emitConstants();
 }
 
 } // end of namespace Ice