Subzero: Emit functions and global initializers in a separate thread.

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 66 matching lines @@
 class LLVM2ICEFunctionConverter : LLVM2ICEConverter {
   LLVM2ICEFunctionConverter(const LLVM2ICEFunctionConverter &) = delete;
   LLVM2ICEFunctionConverter &
   operator=(const LLVM2ICEFunctionConverter &) = delete;
 
 public:
   LLVM2ICEFunctionConverter(Ice::Converter &Converter)
       : LLVM2ICEConverter(Converter), Func(nullptr) {}
 
   void convertFunction(const Function *F) {
-    Func = Ice::Cfg::create(Ctx);
+    if (Ctx->isIRGenerationDisabled())
+      return;
+    Func = Ice::Cfg::create(Ctx, Converter.getNextSequenceNumber());
     Ice::Cfg::setCurrentCfg(Func.get());
 
     VarMap.clear();
     NodeMap.clear();
     Func->setFunctionName(F->getName());
     Func->setReturnType(convertToIceType(F->getReturnType()));
     Func->setInternal(F->hasInternalLinkage());
     Ice::TimerMarker T(Ice::TimerStack::TT_llvmConvert, Func.get());
 
     // The initial definition/use of each arg is the entry node.
@@ skipping 553 matching lines @@
 class LLVM2ICEGlobalsConverter : public LLVM2ICEConverter {
   LLVM2ICEGlobalsConverter(const LLVM2ICEGlobalsConverter &) = delete;
   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::VariableDeclarationList &VariableDeclarations);
+  /// global variable declarations, for module Mod. Returns the set of
+  /// converted declarations.
+  std::unique_ptr<Ice::VariableDeclarationList>
+  convertGlobalsToIce(Module *Mod);
 
 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 14 matching lines @@
       return CI->getSExtValue();
 
     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::VariableDeclarationList &VariableDeclarations) {
+std::unique_ptr<Ice::VariableDeclarationList>
+LLVM2ICEGlobalsConverter::convertGlobalsToIce(Module *Mod) {
+  std::unique_ptr<Ice::VariableDeclarationList> VariableDeclarations(
+      new Ice::VariableDeclarationList);
   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);
+    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().getAllowUninitializedGlobals())
@@ skipping 12 matching lines @@
                                              E = CompoundInit->op_end();
            I != E; ++I) {
         if (const auto Init = dyn_cast<Constant>(I)) {
           addGlobalInitializer(*VarDecl, Init);
         }
       }
     } else {
       addGlobalInitializer(*VarDecl, Initializer);
     }
   }
+  return std::move(VariableDeclarations);
 }
 
 void LLVM2ICEGlobalsConverter::addGlobalInitializer(
     Ice::VariableDeclaration &Global, const Constant *Initializer,
     bool HasOffset, Ice::RelocOffsetT Offset) {
   (void)HasOffset;
   assert(HasOffset || Offset == 0);
 
   if (const auto CDA = dyn_cast<ConstantDataArray>(Initializer)) {
     assert(!HasOffset && isa<IntegerType>(CDA->getElementType()) &&
@@ skipping 42 matching lines @@
   raw_string_ostream StrBuf(Buffer);
   StrBuf << "Unhandled global initializer: " << Initializer;
   report_fatal_error(StrBuf.str());
 }
 
 } // end of anonymous namespace
 
 namespace Ice {
 
 void Converter::nameUnnamedGlobalVariables(Module *Mod) {
-  const IceString &GlobalPrefix = Flags.getDefaultGlobalPrefix();
+  const IceString &GlobalPrefix = Ctx->getFlags().getDefaultGlobalPrefix();
   if (GlobalPrefix.empty())
     return;
   uint32_t NameIndex = 0;
   for (auto V = Mod->global_begin(), E = Mod->global_end(); V != E; ++V) {
     if (!V->hasName()) {
       V->setName(createUnnamedName(GlobalPrefix, NameIndex));
       ++NameIndex;
     } else {
       checkIfUnnamedNameSafe(V->getName(), "global", GlobalPrefix);
     }
   }
 }
 
 void Converter::nameUnnamedFunctions(Module *Mod) {
-  const IceString &FunctionPrefix = Flags.getDefaultFunctionPrefix();
+  const IceString &FunctionPrefix = Ctx->getFlags().getDefaultFunctionPrefix();
   if (FunctionPrefix.empty())
     return;
   uint32_t NameIndex = 0;
   for (Function &F : *Mod) {
     if (!F.hasName()) {
       F.setName(createUnnamedName(FunctionPrefix, NameIndex));
       ++NameIndex;
     } else {
       checkIfUnnamedNameSafe(F.getName(), "function", FunctionPrefix);
     }
@@ skipping 45 matching lines @@
     VariableDeclaration *Var = VariableDeclaration::create();
     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);
-  VariableDeclarationList VariableDeclarations;
-  GlobalsConverter.convertGlobalsToIce(Mod, VariableDeclarations);
-  lowerGlobals(VariableDeclarations);
+  lowerGlobals(LLVM2ICEGlobalsConverter(*this).convertGlobalsToIce(Mod));
 }
 
 void Converter::convertFunctions() {
   const TimerStackIdT StackID = GlobalContext::TSK_Funcs;
   for (const Function &I : *Mod) {
     if (I.empty())
       continue;
 
     TimerIdT TimerID = 0;
     const bool TimeThisFunction = Ctx->getFlags().getTimeEachFunction();
     if (TimeThisFunction) {
       TimerID = Ctx->getTimerID(StackID, I.getName());
       Ctx->pushTimer(TimerID, StackID);
     }
     LLVM2ICEFunctionConverter FunctionConverter(*this);
     FunctionConverter.convertFunction(&I);
     if (TimeThisFunction)
       Ctx->popTimer(TimerID, StackID);
   }
 }
 
 } // end of namespace Ice