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
 // bitcode file and build the LLVM IR, and then convert the LLVM basic
 // blocks, instructions, and operands into their Subzero equivalents.
 //
 //===----------------------------------------------------------------------===//
 
+#include "IceCfg.h"
 #include "IceConverter.h"
 #include "IceDefs.h"
+#include "IceTargetLowering.h"
 #include "IceTypes.h"
 
+#include "llvm/IR/Constant.h"
+#include "llvm/IR/Constants.h"
 #include "llvm/IR/LLVMContext.h"
+#include "llvm/IR/Module.h"
 #include "llvm/IRReader/IRReader.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/raw_os_ostream.h"
 #include "llvm/Support/SourceMgr.h"
 
 #include <fstream>
 #include <iostream>
 
 using namespace llvm;
 
@@ skipping 56 matching lines @@
 static cl::opt<bool> SubzeroTimingEnabled(
     "timing", cl::desc("Enable breakdown timing of Subzero translation"));
 
 static cl::opt<NaClFileFormat> InputFileFormat(
     "bitcode-format", cl::desc("Define format of input file:"),
     cl::values(clEnumValN(LLVMFormat, "llvm", "LLVM file (default)"),
                clEnumValN(PNaClFormat, "pnacl", "PNaCl bitcode file"),
                clEnumValEnd),
     cl::init(LLVMFormat));
 
-static cl::opt<bool> BuildOnRead(
-    "build-on-read", cl::desc("Build ICE instructions when reading bitcode"),
-    cl::init(false));
+static cl::opt<bool>
+BuildOnRead("build-on-read",
+            cl::desc("Build ICE instructions when reading bitcode"),
+            cl::init(false));
 
 int main(int argc, char **argv) {
 
   cl::ParseCommandLineOptions(argc, argv);
 
   Ice::VerboseMask VMask = Ice::IceV_None;
   for (unsigned i = 0; i != VerboseList.size(); ++i)
     VMask |= VerboseList[i];
 
   std::ofstream Ofs;
@@ skipping 12 matching lines @@
 
   Ice::GlobalContext Ctx(Ls, Os, VMask, TargetArch, OptLevel, TestPrefix);
 
   if (BuildOnRead) {
     std::cerr << "Direct build from bitcode not implemented yet!\n";
     return 1;
   } else {
     // Parse the input LLVM IR file into a module.
     SMDiagnostic Err;
     Ice::Timer T;
-    Module *Mod = NaClParseIRFile(IRFilename, InputFileFormat, Err,
-                                  getGlobalContext());
+    Module *Mod =
+        NaClParseIRFile(IRFilename, InputFileFormat, Err, getGlobalContext());
 
     if (SubzeroTimingEnabled) {
       std::cerr << "[Subzero timing] IR Parsing: " << T.getElapsedSec()
                 << " sec\n";
     }
 
     if (!Mod) {
       Err.print(argv[0], errs());
       return 1;
     }
 
+    // TODO(stichnot): Move this into IceConverter.cpp.
+    OwningPtr<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 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, DisableTranslation);
+    }
+    GlobalLowering.reset();
+
     Ice::Converter Converter(&Ctx, DisableInternal, SubzeroTimingEnabled,
                              DisableTranslation);
     return Converter.convertToIce(Mod);
   }
 }