Subzero: Partial implementation of global initializers.

src/llvm2ice.cpp

 //===- subzero/src/llvm2ice.cpp - Driver for testing ----------------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines a driver that uses LLVM capabilities to parse a
@@ skipping 708 matching lines @@
   raw_os_ostream *Os =
       new raw_os_ostream(OutputFilename == "-" ? std::cout : Ofs);
   Os->SetUnbuffered();
   std::ofstream Lfs;
   if (LogFilename != "-") {
     Lfs.open(LogFilename.c_str(), std::ofstream::out);
   }
   raw_os_ostream *Ls = new raw_os_ostream(LogFilename == "-" ? std::cout : Lfs);
   Ls->SetUnbuffered();
 
+  Ice::GlobalContext Ctx(Ls, Os, VMask, TargetArch, OptLevel, TestPrefix);
+
+  Ice::TargetGlobalInitLowering *GlobalLowering =
+      Ice::TargetGlobalInitLowering::createLowering(TargetArch, &Ctx);
+  for (Module::const_global_iterator I = Mod->global_begin(),
+                                     E = Mod->global_end();
+       I != E; ++I) {
+    if (!I->hasInitializer())
+      continue;
+    const Constant *Initializer = I->getInitializer();
+    Ice::IceString Name = I->getName();
+    unsigned Align = I->getAlignment();
+    uint64_t NumElements = 0;
+    const char *Data = NULL;
+    bool DeleteData = false;
+    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();
+        char *MyData = new char[NumElements];
+        memset(MyData, 0, NumElements);
+        Data = MyData;
+        DeleteData = true;
+        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, DisableTranslation);
+    if (DeleteData)
+      delete Data;
+  }
+  delete GlobalLowering;
+
   // Ideally, Func would be declared inside the loop and its object
   // would be automatically deleted at the end of the loop iteration.
   // However, emitting the constant pool requires a valid Cfg object,
   // so we need to defer deleting the last non-empty Cfg object until
   // outside the loop and after emitting the constant pool.  TODO:
   // Since all constants are globally pooled in the Ice::GlobalContext
   // object, change all Ice::Constant related functions to use
   // GlobalContext instead of Cfg, and then clean up this loop.
   OwningPtr<Ice::Cfg> Func;
-  Ice::GlobalContext Ctx(Ls, Os, VMask, TargetArch, OptLevel, TestPrefix);
 
   for (Module::const_iterator I = Mod->begin(), E = Mod->end(); I != E; ++I) {
     if (I->empty())
       continue;
     LLVM2ICEConverter FunctionConverter(&Ctx);
 
     Ice::Timer TConvert;
     Func.reset(FunctionConverter.convertFunction(I));
     if (DisableInternal)
       Func->setInternal(false);
@@ skipping 27 matching lines @@
                   << " sec\n";
       }
     }
   }
 
   if (!DisableTranslation && Func)
     Func->getTarget()->emitConstants();
 
   return ExitStatus;
 }