[opt] Remove some legacy PM specific flags/passes

[aeubanks]

Summary

These look like they haven't been touched in a long time.

[asbirlea]

Could you check on discourse these are truely not used?
If you have, please include link in description.
It can be revisited if users do show up once removed.

llvm/docs/Passes.rst

 standard error in a human-readable form.
 
 ``-print-cfg-sccs``: Print SCCs of each function CFG
 ----------------------------------------------------
 
 This pass, only available in ``opt``, printsthe SCCs of each function CFG to
 standard error in a human-readable fom.
 
-``-print-externalfnconstants``: Print external fn callsites passed constants
-----------------------------------------------------------------------------
-
-This pass, only available in ``opt``, prints out call sites to external
-functions that are called with constant arguments.  This can be useful when
-looking for standard library functions we should constant fold or handle in
-alias analyses.
-
 ``-print-function``: Print function to stderr
 ---------------------------------------------
 
 The ``PrintFunctionPass`` class is designed to be pipelined with other
 ``FunctionPasses``, and prints out the functions of the module as they are
 processed.
 
 ``-print-module``: Print module to stderr

llvm/tools/opt/AnalysisWrappers.cpp

-//===- AnalysisWrappers.cpp - Wrappers around non-pass analyses -----------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines pass wrappers around LLVM analyses that don't make sense to
-// be passes.  It provides a nice standard pass interface to these classes so
-// that they can be printed out by analyze.
-//
-// These classes are separated out of analyze.cpp so that it is more clear which
-// code is the integral part of the analyze tool, and which part of the code is
-// just making it so more passes are available.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/Analysis/CallGraph.h"
-#include "llvm/IR/Module.h"
-#include "llvm/Pass.h"
-#include "llvm/Support/raw_ostream.h"
-using namespace llvm;
-
-namespace {
-  /// ExternalFunctionsPassedConstants - This pass prints out call sites to
-  /// external functions that are called with constant arguments.  This can be
-  /// useful when looking for standard library functions we should constant fold
-  /// or handle in alias analyses.
-  struct ExternalFunctionsPassedConstants : public ModulePass {
-    static char ID; // Pass ID, replacement for typeid
-    ExternalFunctionsPassedConstants() : ModulePass(ID) {}
-    bool runOnModule(Module &M) override {
-      for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) {
-        if (!I->isDeclaration()) continue;
-
-        bool PrintedFn = false;
-        for (User *U : I->users()) {
-          Instruction *UI = dyn_cast<Instruction>(U);
-          if (!UI) continue;
-
-          CallBase *CB = dyn_cast<CallBase>(UI);
-          if (!CB)
-            continue;
-
-          for (auto AI = CB->arg_begin(), E = CB->arg_end(); AI != E; ++AI) {
-            if (!isa<Constant>(*AI)) continue;
-
-            if (!PrintedFn) {
-              errs() << "Function '" << I->getName() << "':\n";
-              PrintedFn = true;
-            }
-            errs() << *UI;
-            break;
-          }
-        }
-      }
-
-      return false;
-    }
-
-    void getAnalysisUsage(AnalysisUsage &AU) const override {
-      AU.setPreservesAll();
-    }
-  };
-}
-
-char ExternalFunctionsPassedConstants::ID = 0;
-static RegisterPass<ExternalFunctionsPassedConstants>
-  P1("print-externalfnconstants",
-     "Print external fn callsites passed constants");

llvm/tools/opt/BreakpointPrinter.h

-//===- BreakpointPrinter.h - Breakpoint location printer ------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-/// Breakpoint location printer.
-///
-//===----------------------------------------------------------------------===//
-#ifndef LLVM_TOOLS_OPT_BREAKPOINTPRINTER_H
-#define LLVM_TOOLS_OPT_BREAKPOINTPRINTER_H
-
-namespace llvm {
-
-class ModulePass;
-class raw_ostream;
-
-ModulePass *createBreakpointPrinter(raw_ostream &out);
-}
-
-#endif // LLVM_TOOLS_OPT_BREAKPOINTPRINTER_H

llvm/tools/opt/BreakpointPrinter.cpp

-//===- BreakpointPrinter.cpp - Breakpoint location printer ----------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-/// Breakpoint location printer.
-///
-//===----------------------------------------------------------------------===//
-#include "BreakpointPrinter.h"
-#include "llvm/ADT/StringSet.h"
-#include "llvm/IR/DebugInfo.h"
-#include "llvm/IR/Module.h"
-#include "llvm/Pass.h"
-#include "llvm/Support/raw_ostream.h"
-
-using namespace llvm;
-
-namespace {
-
-struct BreakpointPrinter : public ModulePass {
-  raw_ostream &Out;
-  static char ID;
-
-  BreakpointPrinter(raw_ostream &out) : ModulePass(ID), Out(out) {}
-
-  void getContextName(const DIScope *Context, std::string &N) {
-    if (auto *NS = dyn_cast<DINamespace>(Context)) {
-      if (!NS->getName().empty()) {
-        getContextName(NS->getScope(), N);
-        N = N + NS->getName().str() + "::";
-      }
-    } else if (auto *TY = dyn_cast<DIType>(Context)) {
-      if (!TY->getName().empty()) {
-        getContextName(TY->getScope(), N);
-        N = N + TY->getName().str() + "::";
-      }
-    }
-  }
-
-  bool runOnModule(Module &M) override {
-    StringSet<> Processed;
-    if (NamedMDNode *NMD = M.getNamedMetadata("llvm.dbg.sp"))
-      for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
-        std::string Name;
-        auto *SP = cast_or_null<DISubprogram>(NMD->getOperand(i));
-        if (!SP)
-          continue;
-        getContextName(SP->getScope(), Name);
-        Name = Name + SP->getName().str();
-        if (!Name.empty() && Processed.insert(Name).second) {
-          Out << Name << "\n";
-        }
-      }
-    return false;
-  }
-
-  void getAnalysisUsage(AnalysisUsage &AU) const override {
-    AU.setPreservesAll();
-  }
-};
-
-char BreakpointPrinter::ID = 0;
-}
-
-ModulePass *llvm::createBreakpointPrinter(raw_ostream &out) {
-  return new BreakpointPrinter(out);
-}

llvm/tools/opt/CMakeLists.txt

set(LLVM_LINK_COMPONENTS
   Support
   Target
   TransformUtils
   Vectorize
   Passes
   )
 
 add_llvm_tool(opt
-  AnalysisWrappers.cpp
-  BreakpointPrinter.cpp
   NewPMDriver.cpp
   PrintSCC.cpp
   opt.cpp
 
   DEPENDS
   intrinsics_gen
   SUPPORT_PLUGINS
   )
 export_executable_symbols_for_plugins(opt)
 
 if(LLVM_BUILD_EXAMPLES)
     target_link_libraries(opt PRIVATE ExampleIRTransforms)
 endif(LLVM_BUILD_EXAMPLES)

llvm/tools/opt/opt.cpp

 //===- opt.cpp - The LLVM Modular Optimizer -------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Optimizations may be specified an arbitrary number of times on the command
 // line, They are run in the order specified.
 //
 //===----------------------------------------------------------------------===//
 
-#include "BreakpointPrinter.h"
 #include "NewPMDriver.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Analysis/CallGraph.h"
 #include "llvm/Analysis/CallGraphSCCPass.h"
 #include "llvm/Analysis/LoopPass.h"
 #include "llvm/Analysis/RegionPass.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
static cl::opt<bool> EnableDebugify(
     cl::desc(
         "Start the pipeline with debugify and end it with check-debugify"));
 
 static cl::opt<bool> VerifyDebugInfoPreserve(
     "verify-debuginfo-preserve",
     cl::desc("Start the pipeline with collecting and end it with checking of "
              "debug info preservation."));
 
-static cl::opt<bool>
-PrintBreakpoints("print-breakpoints-for-testing",
-                 cl::desc("Print select breakpoints location for testing"));
-
 static cl::opt<std::string> ClDataLayout("data-layout",
                                          cl::desc("data layout string to use"),
                                          cl::value_desc("layout-string"),
                                          cl::init(""));
 
 static cl::opt<bool> PreserveBitcodeUseListOrder(
     "preserve-bc-uselistorder",
     cl::desc("Preserve use-list order when writing LLVM bitcode."),
#endif
   std::unique_ptr<legacy::FunctionPassManager> FPasses;
   if (OptLevelO0 || OptLevelO1 || OptLevelO2 || OptLevelOs || OptLevelOz ||
       OptLevelO3) {
     FPasses.reset(new legacy::FunctionPassManager(M.get()));
     FPasses->add(createTargetTransformInfoWrapperPass(
         TM ? TM->getTargetIRAnalysis() : TargetIRAnalysis()));
   }
 
-  if (PrintBreakpoints) {
-    // Default to standard output.
-    if (!Out) {
-      if (OutputFilename.empty())
-        OutputFilename = "-";
-
-      std::error_code EC;
-      Out = std::make_unique<ToolOutputFile>(OutputFilename, EC,
-                                              sys::fs::OF_None);
-      if (EC) {
-        errs() << EC.message() << '\n';
-        return 1;
-      }
-    }
-    Passes.add(createBreakpointPrinter(Out->os()));
-    NoOutput = true;
-  }
-
   if (TM) {
     // FIXME: We should dyn_cast this when supported.
     auto &LTM = static_cast<LLVMTargetMachine &>(*TM);
     Pass *TPC = LTM.createPassConfig(Passes);
     Passes.add(TPC);
   }
 
   // Create a new optimization pass for each one specified on the command line
if (!RunTwice) {
     if (ShouldEmitOutput)
       Out->os() << BOS->str();
   }
 
   if (DebugifyEach && !DebugifyExport.empty())
     exportDebugifyStats(DebugifyExport, Passes.getDebugifyStatsMap());
 
   // Declare success.
-  if (!NoOutput || PrintBreakpoints)
+  if (!NoOutput)
     Out->keep();
 
   if (RemarksFile)
     RemarksFile->keep();
 
   if (ThinLinkOut)
     ThinLinkOut->keep();
 
   return 0;
 }

llvm/utils/gn/secondary/llvm/tools/opt/BUILD.gn

deps = [
     "//llvm/lib/Transforms/IPO",
     "//llvm/lib/Transforms/Instrumentation",
     "//llvm/lib/Transforms/ObjCARC",
     "//llvm/lib/Transforms/Scalar",
     "//llvm/lib/Transforms/Utils",
     "//llvm/lib/Transforms/Vectorize",
   ]
   sources = [
-    "AnalysisWrappers.cpp",
-    "BreakpointPrinter.cpp",
     "NewPMDriver.cpp",
     "PrintSCC.cpp",
     "opt.cpp",
   ]
 
   # Support plugins.
   # FIXME: Disable dead stripping once other binaries are dead-stripped.
   if (host_os != "mac" && host_os != "win") {
     # Corresponds to export_executable_symbols() in cmake.
     ldflags = [ "-rdynamic" ]
   }
 }