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

Otherwise every thread will translate every function and
we end up with duplicates. I.e., we cannot leave out
-streaming-bitcode and translate with more than one
thread (which is the default in pnacl-translate).
The -streaming-bitcode flag still affects how the
bitcode is read in however (everything materialized
at once or lazily), so "createPNaClABIVerifyModulePass(&ABIErrorReporter, LazyBitcode)"
is left alone.

Ultimately, this is to help make it easy to temporarily
leave off "-streaming-bitcode" until we find the source of
non-determinism. Switching to FunctionPassManager does not
affect the non-determinism either way (so the problem
may be in the materialization or something else instead):
BUG= https://code.google.com/p/nativeclient/issues/detail?id=4101
BUG= https://code.google.com/p/chromium/issues/detail?id=429358
[email protected]

Review URL: https://codereview.chromium.org/1121433002

Author: Jan Voung

tools/pnacl-llc/pnacl-llc.cpp

@@ -428,11 +428,9 @@ static int runCompilePasses(Module *ModuleRef,
   }
 
   // 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())
@@ -475,59 +473,54 @@ static int runCompilePasses(Module *ModuleRef,
     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();
-        }
-        ++FuncIndex;
+  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();
       }
-      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;
+      ++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;
           }
-        } else {
-          while (FuncIndex < NextIndex) {
-            if (!I->isMaterializable() && I->isDeclaration()) {
-              ++I;
-              continue;
-            }
-            ++FuncIndex;
+          PM->run(*I);
+          CheckABIVerifyErrors(ABIErrorReporter, "Function " + I->getName());
+          I->Dematerialize();
+          ++FuncIndex;
+          ++I;
+        }
+      } else {
+        while (FuncIndex < NextIndex) {
+          if (!I->isMaterializable() && I->isDeclaration()) {
             ++I;
+            continue;
           }
+          ++FuncIndex;
+          ++I;
         }
       }
-      break;
     }
-    FPM->doFinalization();
-  } else
-    static_cast<PassManager *>(PM.get())->run(*ModuleRef);
-
+    break;
+  }
+  PM->doFinalization();
   return 0;
 }