Test generation of global initializers in Subzero bitcode reader.

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 609 matching lines @@
   Ice::TypeConverter TypeConverter;
 };
 
 } // end of anonymous namespace
 
 namespace Ice {
 
 void Converter::convertToIce() {
   nameUnnamedGlobalAddresses(Mod);
   if (!Ctx->getFlags().DisableGlobals)
-    convertGlobals();
+    convertGlobals(Mod);
   convertFunctions();
 }
 
-void Converter::convertGlobals() {
-  OwningPtr<TargetGlobalInitLowering> GlobalLowering(
-      TargetGlobalInitLowering::createLowering(Ctx->getTargetArch(), Ctx));
-  for (Module::const_global_iterator I = Mod->global_begin(),
-                                     E = Mod->global_end();
-       I != E; ++I) {
-    if (!I->hasInitializer())
-      continue;
-    const llvm::Constant *Initializer = I->getInitializer();
-    IceString Name = I->getName();
-    unsigned Align = I->getAlignment();
-    uint64_t NumElements = 0;
-    const char *Data = NULL;
-    bool IsInternal = I->hasInternalLinkage();
-    bool IsConst = I->isConstant();
-    bool IsZeroInitializer = false;
-
-    if (const ConstantDataArray *CDA =
-            dyn_cast<ConstantDataArray>(Initializer)) {
-      NumElements = CDA->getNumElements();
-      assert(isa<IntegerType>(CDA->getElementType()) &&
-             cast<IntegerType>(CDA->getElementType())->getBitWidth() == 8);
-      Data = CDA->getRawDataValues().data();
-    } else if (isa<ConstantAggregateZero>(Initializer)) {
-      if (const ArrayType *AT = dyn_cast<ArrayType>(Initializer->getType())) {
-        assert(isa<IntegerType>(AT->getElementType()) &&
-               cast<IntegerType>(AT->getElementType())->getBitWidth() == 8);
-        NumElements = AT->getNumElements();
-        IsZeroInitializer = true;
-      } else {
-        llvm_unreachable("Unhandled constant aggregate zero type");
-      }
-    } else {
-      llvm_unreachable("Unhandled global initializer");
-    }
-
-    GlobalLowering->lower(Name, Align, IsInternal, IsConst, IsZeroInitializer,
-                          NumElements, Data,
-                          Ctx->getFlags().DisableTranslation);
-  }
-  GlobalLowering.reset();
-}
-
 void Converter::convertFunctions() {
   for (Module::const_iterator I = Mod->begin(), E = Mod->end(); I != E; ++I) {
     if (I->empty())
       continue;
     LLVM2ICEConverter FunctionConverter(Ctx, Mod->getContext());
 
     Timer TConvert;
     Cfg *Fcn = FunctionConverter.convertFunction(I);
     if (Ctx->getFlags().SubzeroTimingEnabled) {
       std::cerr << "[Subzero timing] Convert function "
                 << Fcn->getFunctionName() << ": " << TConvert.getElapsedSec()
                 << " sec\n";
     }
     translateFcn(Fcn);
   }
 
   emitConstants();
 }
 
 } // end of namespace Ice