Fix handling of relocation names, so that prefix mangling works.

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 96 matching lines @@
     Func->computePredecessors();
 
     return Func;
   }
 
   // convertConstant() does not use Func or require it to be a valid
   // Ice::Cfg pointer.  As such, it's suitable for e.g. constructing
   // global initializers.
   Ice::Constant *convertConstant(const Constant *Const) {
     if (const auto GV = dyn_cast<GlobalValue>(Const)) {
-      return Ctx->getConstantSym(convertToIceType(GV->getType()), 0,
-                                 GV->getName());
+      Ice::GlobalDeclaration *Decl = getConverter().getGlobalDeclaration(GV);
+      const Ice::RelocOffsetT Offset = 0;
+      return Ctx->getConstantSym(TypeConverter.getIcePointerType(),
+                                 Offset, Decl->getName(),
+                                 Decl->getSuppressMangling());
     } else if (const auto CI = dyn_cast<ConstantInt>(Const)) {
       Ice::Type Ty = convertToIceType(CI->getType());
       if (Ty == Ice::IceType_i64) {
         return Ctx->getConstantInt64(Ty, CI->getSExtValue());
       } else {
         return Ctx->getConstantInt32(Ty, CI->getSExtValue());
       }
     } else if (const auto CFP = dyn_cast<ConstantFP>(Const)) {
       Ice::Type Type = convertToIceType(CFP->getType());
       if (Type == Ice::IceType_f32)
@@ skipping 554 matching lines @@
     return 0;
   }
 };
 
 void LLVM2ICEGlobalsConverter::convertGlobalsToIce(
     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 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 declaration: " << Name;
-      report_fatal_error(StrBuf.str());
-    }
 
     Ice::GlobalDeclaration *Var = getConverter().getGlobalDeclaration(GV);
     Ice::VariableDeclaration* VarDecl = cast<Ice::VariableDeclaration>(Var);
     VariableDeclarations.push_back(VarDecl);
 
+    if (!GV->hasInternalLinkage() && GV->hasInitializer()) {
+      std::string Buffer;
+      raw_string_ostream StrBuf(Buffer);
+      StrBuf << "Can't define external global declaration: " << GV->getName();
+      report_fatal_error(StrBuf.str());
+    }
+
+    if (!GV->hasInitializer()) {
+      if (Ctx->getFlags().AllowUninitializedGlobals)
+        continue;
+      else {
+        std::string Buffer;
+        raw_string_ostream StrBuf(Buffer);
+        StrBuf << "Global declaration missing initializer: " << GV->getName();
+        report_fatal_error(StrBuf.str());
+      }
+    }
+
     const Constant *Initializer = GV->getInitializer();
     if (const auto CompoundInit = dyn_cast<ConstantStruct>(Initializer)) {
       for (ConstantStruct::const_op_iterator I = CompoundInit->op_begin(),
                                              E = CompoundInit->op_end();
            I != E; ++I) {
         if (const auto Init = dyn_cast<Constant>(I)) {
           addGlobalInitializer(*VarDecl, Init);
         }
       }
     } else {
@@ skipping 132 matching lines @@
   }
   // 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());
+    Var->setLinkage(GV->getLinkage());
     GlobalDeclarationMap[GV] = Var;
   }
 }
 
 void Converter::convertGlobals(Module *Mod) {
   LLVM2ICEGlobalsConverter GlobalsConverter(*this);
   Translator::VariableDeclarationListType VariableDeclarations;
   GlobalsConverter.convertGlobalsToIce(Mod, VariableDeclarations);
   lowerGlobals(VariableDeclarations);
 }
@@ skipping 14 matching lines @@
     Cfg *Fcn = FunctionConverter.convertFunction(&I);
     translateFcn(Fcn);
     if (Ctx->getFlags().TimeEachFunction)
       Ctx->popTimer(TimerID, StackID);
   }
 
   emitConstants();
 }
 
 } // end of namespace Ice