Always use a FunctionPassManager in pnacl-llc. MPPassManager breaks threading.

tools/pnacl-llc/pnacl-llc.cpp

 //===-- pnacl-llc.cpp - PNaCl-specific llc: pexe ---> nexe  ---------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // pnacl-llc: the core of the PNaCl translator, compiling a pexe into a nexe.
@@ skipping 410 matching lines @@
       F.setVisibility(GlobalValue::HiddenVisibility);
   }
   for (Module::global_iterator GI = ModuleRef->global_begin(),
            GE = ModuleRef->global_end();
        GI != GE; ++GI) {
     if (!GI->isWeakForLinker() && !GI->hasLocalLinkage())
       GI->setVisibility(GlobalValue::HiddenVisibility);
   }
 
   // Build up all of the passes that we want to do to the module.
-  std::unique_ptr<PassManagerBase> PM;
-  if (LazyBitcode)
-    PM.reset(new FunctionPassManager(ModuleRef));
-  else
-    PM.reset(new PassManager());
+  // We always use a FunctionPassManager to divide up the functions
+  // among threads (instead of a whole-module PassManager).
+  std::unique_ptr<FunctionPassManager> PM(new FunctionPassManager(ModuleRef));
 
   // Add the target data from the target machine, if it exists, or the module.
   if (const DataLayout *DL = Target.getSubtargetImpl()->getDataLayout())
     ModuleRef->setDataLayout(DL);
   PM->add(new DataLayoutPass());
 
   // For conformance with llc, we let the user disable LLVM IR verification with
   // -disable-verify. Unlike llc, when LLVM IR verification is enabled we only
   // run it once, before PNaCl ABI verification.
   if (!NoVerify)
@@ skipping 22 matching lines @@
 
   // Ask the target to add backend passes as necessary. We explicitly ask it
   // not to add the verifier pass because we added it earlier.
   if (Target.addPassesToEmitFile(*PM, FOS, FileType,
                                  /* DisableVerify */ true)) {
     errs() << ProgramName
     << ": target does not support generation of this file type!\n";
     return 1;
   }
 
-  if (LazyBitcode) {
-    auto FPM = static_cast<FunctionPassManager *>(PM.get());
-    FPM->doInitialization();
-    unsigned FuncIndex = 0;
-    switch (SplitModuleSched) {
-    case SplitModuleStatic:
-      for (Function &F : *ModuleRef) {
-        if (FuncQueue->GrabFunctionStatic(FuncIndex, ModuleIndex)) {
-          FPM->run(F);
-          CheckABIVerifyErrors(ABIErrorReporter, "Function " + F.getName());
-          F.Dematerialize();
+  PM->doInitialization();
+  unsigned FuncIndex = 0;
+  switch (SplitModuleSched) {
+  case SplitModuleStatic:
+    for (Function &F : *ModuleRef) {
+      if (FuncQueue->GrabFunctionStatic(FuncIndex, ModuleIndex)) {
+        PM->run(F);
+        CheckABIVerifyErrors(ABIErrorReporter, "Function " + F.getName());
+        F.Dematerialize();
+      }
+      ++FuncIndex;
+    }
+    break;
+  case SplitModuleDynamic:
+    unsigned ChunkSize = 0;
+    unsigned NumFunctions = FuncQueue->Size();
+    Module::iterator I = ModuleRef->begin();
+    while (FuncIndex < NumFunctions) {
+      ChunkSize = FuncQueue->RecommendedChunkSize();
+      unsigned NextIndex;
+      bool grabbed =
+          FuncQueue->GrabFunctionDynamic(FuncIndex, ChunkSize, NextIndex);
+      if (grabbed) {
+        while (FuncIndex < NextIndex) {
+          if (!I->isMaterializable() && I->isDeclaration()) {
+            ++I;
+            continue;
+          }
+          PM->run(*I);
+          CheckABIVerifyErrors(ABIErrorReporter, "Function " + I->getName());
+          I->Dematerialize();
+          ++FuncIndex;
+          ++I;
         }
-        ++FuncIndex;
-      }
-      break;
-    case SplitModuleDynamic:
-      unsigned ChunkSize = 0;
-      unsigned NumFunctions = FuncQueue->Size();
-      Module::iterator I = ModuleRef->begin();
-      while (FuncIndex < NumFunctions) {
-        ChunkSize = FuncQueue->RecommendedChunkSize();
-        unsigned NextIndex;
-        bool grabbed = FuncQueue->GrabFunctionDynamic(FuncIndex, ChunkSize,
-                                                      NextIndex);
-        if (grabbed) {
-          while (FuncIndex < NextIndex) {
-            if (!I->isMaterializable() && I->isDeclaration()) {
-              ++I;
-              continue;
-            }
-            FPM->run(*I);
-            CheckABIVerifyErrors(ABIErrorReporter, "Function " + I->getName());
-            I->Dematerialize();
-            ++FuncIndex;
+      } else {
+        while (FuncIndex < NextIndex) {
+          if (!I->isMaterializable() && I->isDeclaration()) {
             ++I;
+            continue;
           }
-        } else {
-          while (FuncIndex < NextIndex) {
-            if (!I->isMaterializable() && I->isDeclaration()) {
-              ++I;
-              continue;
-            }
-            ++FuncIndex;
-            ++I;
-          }
+          ++FuncIndex;
+          ++I;
         }
       }
-      break;
     }
-    FPM->doFinalization();
-  } else
-    static_cast<PassManager *>(PM.get())->run(*ModuleRef);
-
+    break;
+  }
+  PM->doFinalization();
   return 0;
 }
 
 static int compileSplitModule(const TargetOptions &Options,
                               const Triple &TheTriple,
                               const Target *TheTarget,
                               const std::string &FeaturesStr,
                               CodeGenOpt::Level OLvl,
                               const StringRef &ProgramName,
                               Module *GlobalModuleRef,
@@ skipping 235 matching lines @@
   return 0;
 }
 
 int main(int argc, char **argv) {
 #if defined(PNACL_BROWSER_TRANSLATOR)
   return srpc_main(argc, argv);
 #else
   return llc_main(argc, argv);
 #endif // PNACL_BROWSER_TRANSLATOR
 }