IPO: Remove the ModuleSummary argument to the FunctionImport pass. NFCI.

[pcc]

Summary

No existing client is passing a non-null value here. This will come back
in a slightly different form as part of the type identifier summary work.

[mehdi_amini]

LGTM, thanks.

llvm/trunk/include/llvm/Transforms/IPO.h

 /// the specified global values. Otherwise, it deletes as much of the module as
 /// possible, except for the global values specified.
 ///
 ModulePass *createGVExtractionPass(std::vector<GlobalValue*>& GVs, bool
                                    deleteFn = false);
 
 //===----------------------------------------------------------------------===//
 /// This pass performs iterative function importing from other modules.
-Pass *createFunctionImportPass(const ModuleSummaryIndex *Index = nullptr);
+Pass *createFunctionImportPass();
 
 //===----------------------------------------------------------------------===//
 /// createFunctionInliningPass - Return a new pass object that uses a heuristic
 /// to inline direct function calls to small functions.
 ///
 /// The Threshold can be passed directly, or asked to be computed from the
 /// given optimization and size optimization arguments.
 ///

llvm/trunk/include/llvm/Transforms/IPO/FunctionImport.h

private:
 
   /// Factory function to load a Module for a given identifier
   ModuleLoaderTy ModuleLoader;
 };
 
 /// The function importing pass
 class FunctionImportPass : public PassInfoMixin<FunctionImportPass> {
 public:
-  FunctionImportPass(const ModuleSummaryIndex *Index = nullptr)
-      : Index(Index) {}
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
-
-private:
-  const ModuleSummaryIndex *Index;
 };
 
 /// Compute all the imports and exports for every module in the Index.
 ///
 /// \p ModuleToDefinedGVSummaries contains for each Module a map
 /// (GUID -> Summary) for every global defined in the module.
 ///
 /// \p ImportLists will be populated with an entry for every Module we are

llvm/trunk/include/llvm/Transforms/IPO/PassManagerBuilder.h

public:
   /// optimizer.  If this is non-null, it is added to both the function and
   /// per-module pass pipeline.
   TargetLibraryInfoImpl *LibraryInfo;
 
   /// Inliner - Specifies the inliner to use.  If this is non-null, it is
   /// added to the per-module passes.
   Pass *Inliner;
 
-  /// The module summary index to use for function importing.
-  const ModuleSummaryIndex *ModuleSummary;
-
   bool DisableTailCalls;
   bool DisableUnitAtATime;
   bool DisableUnrollLoops;
   bool BBVectorize;
   bool SLPVectorize;
   bool LoopVectorize;
   bool RerollLoops;
   bool LoadCombine;

llvm/trunk/lib/Transforms/IPO/FunctionImport.cpp

 }
 
 /// Summary file to use for function importing when using -function-import from
 /// the command line.
 static cl::opt<std::string>
     SummaryFile("summary-file",
                 cl::desc("The summary file to use for function importing."));
 
-static bool doImportingForModule(Module &M, const ModuleSummaryIndex *Index) {
-  if (SummaryFile.empty() && !Index)
-    report_fatal_error("error: -function-import requires -summary-file or "
-                       "file from frontend\n");
-  std::unique_ptr<ModuleSummaryIndex> IndexPtr;
-  if (!SummaryFile.empty()) {
-    if (Index)
-      report_fatal_error("error: -summary-file and index from frontend\n");
-    Expected<std::unique_ptr<ModuleSummaryIndex>> IndexPtrOrErr =
-        getModuleSummaryIndexForFile(SummaryFile);
-    if (!IndexPtrOrErr) {
-      logAllUnhandledErrors(IndexPtrOrErr.takeError(), errs(),
-                            "Error loading file '" + SummaryFile + "': ");
-      return false;
-    }
-    IndexPtr = std::move(*IndexPtrOrErr);
-    Index = IndexPtr.get();
-  }
+static bool doImportingForModule(Module &M) {
+  if (SummaryFile.empty())
+    report_fatal_error("error: -function-import requires -summary-file\n");
+  std::unique_ptr<ModuleSummaryIndex> Index = std::move(*IndexPtrOrErr);
 
   // First step is collecting the import list.
   FunctionImporter::ImportMapTy ImportList;
   ComputeCrossModuleImportForModule(M.getModuleIdentifier(), *Index,
                                     ImportList);
 
   // Conservatively mark all internal values as promoted. This interface is
   // only used when doing importing via the function importing pass. The pass
static bool doImportingForModule(Module &M) {
   }
 
   return *Result;
 }
 
 namespace {
 /// Pass that performs cross-module function import provided a summary file.
 class FunctionImportLegacyPass : public ModulePass {
-  /// Optional module summary index to use for importing, otherwise
-  /// the summary-file option must be specified.
-  const ModuleSummaryIndex *Index;
-
 public:
   /// Pass identification, replacement for typeid
   static char ID;
 
   /// Specify pass name for debug output
   StringRef getPassName() const override { return "Function Importing"; }
 
-  explicit FunctionImportLegacyPass(const ModuleSummaryIndex *Index = nullptr)
-      : ModulePass(ID), Index(Index) {}
+  explicit FunctionImportLegacyPass() : ModulePass(ID) {}
 
   bool runOnModule(Module &M) override {
     if (skipModule(M))
       return false;
 
-    return doImportingForModule(M, Index);
+    return doImportingForModule(M);
   }
 };
 } // anonymous namespace
 
 PreservedAnalyses FunctionImportPass::run(Module &M,
                                           ModuleAnalysisManager &AM) {
-  if (!doImportingForModule(M, Index))
+  if (!doImportingForModule(M))
     return PreservedAnalyses::all();
 
   return PreservedAnalyses::none();
 }
 
 char FunctionImportLegacyPass::ID = 0;
 INITIALIZE_PASS(FunctionImportLegacyPass, "function-import",
                 "Summary Based Function Import", false, false)
 
 namespace llvm {
-Pass *createFunctionImportPass(const ModuleSummaryIndex *Index = nullptr) {
-  return new FunctionImportLegacyPass(Index);
+Pass *createFunctionImportPass() {
+  return new FunctionImportLegacyPass();
 }
 }

llvm/trunk/lib/Transforms/IPO/PassManagerBuilder.cpp

DisableLibCallsShrinkWrap("disable-libcalls-shrinkwrap", cl::init(false),
                               cl::Hidden,
                               cl::desc("Disable shrink-wrap library calls"));
 
 PassManagerBuilder::PassManagerBuilder() {
     OptLevel = 2;
     SizeLevel = 0;
     LibraryInfo = nullptr;
     Inliner = nullptr;
-    ModuleSummary = nullptr;
     DisableUnitAtATime = false;
     DisableUnrollLoops = false;
     BBVectorize = RunBBVectorization;
     SLPVectorize = RunSLPVectorization;
     LoopVectorize = RunLoopVectorization;
     RerollLoops = RunLoopRerolling;
     LoadCombine = RunLoadCombine;
     DisableGVNLoadPRE = false;

 void PassManagerBuilder::addLTOOptimizationPasses(legacy::PassManagerBase &PM) {
   // Remove unused virtual tables to improve the quality of code generated by
   // whole-program devirtualization and bitset lowering.
   PM.add(createGlobalDCEPass());
 
   // Provide AliasAnalysis services for optimizations.
   addInitialAliasAnalysisPasses(PM);
 
-  if (ModuleSummary)
-    PM.add(createFunctionImportPass(ModuleSummary));
-
   // Allow forcing function attributes as a debugging and tuning aid.
   PM.add(createForceFunctionAttrsLegacyPass());
 
   // Infer attributes about declarations if possible.
   PM.add(createInferFunctionAttrsLegacyPass());
 
   if (OptLevel > 1) {
     // Indirect call promotion. This should promote all the targets that are

 
 void PassManagerBuilder::populateThinLTOPassManager(
     legacy::PassManagerBase &PM) {
   PerformThinLTO = true;
 
   if (VerifyInput)
     PM.add(createVerifierPass());
 
-  if (ModuleSummary)
-    PM.add(createFunctionImportPass(ModuleSummary));
-
   populateModulePassManager(PM);
 
   if (VerifyOutput)
     PM.add(createVerifierPass());
   PerformThinLTO = false;
 }
 
 void PassManagerBuilder::populateLTOPassManager(legacy::PassManagerBase &PM) {