squiid/llvm
1
0
Fork 0
Code Issues Pull requests Activity

[opt] Remove -analyze option

Browse source 
This is legacy PM-specific, which is deprecated.

Uses of this should be replaced with a corresponding `-passes='print<foo>'`.

Reviewed By: asbirlea

Differential Revision: https://reviews.llvm.org/D122420
This commit is contained in:
Arthur Eubanks 2022-02-10 15:39:29 -08:00
parent cf9c606a97
commit df0b893d94
6 changed files with 3 additions and 297 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
llvm/tools/opt/CMakeLists.txt
View file

@ -32,7 +32,6 @@ add_llvm_tool(opt
BreakpointPrinter.cpp
GraphPrinters.cpp
NewPMDriver.cpp
PassPrinters.cpp
PrintSCC.cpp
opt.cpp

1
llvm/tools/opt/NewPMDriver.cpp
View file

@ -13,7 +13,6 @@
//===----------------------------------------------------------------------===//
#include "NewPMDriver.h"
#include "PassPrinters.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Analysis/AliasAnalysis.h"

212
llvm/tools/opt/PassPrinters.cpp
View file

@ -1,212 +0,0 @@
//===- PassPrinters.cpp - Utilities to print analysis info for passes -----===//
//
// 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
/// Utilities to print analysis info for various kinds of passes.
///
//===----------------------------------------------------------------------===//
#include "PassPrinters.h"
#include "llvm/Analysis/CallGraph.h"
#include "llvm/Analysis/CallGraphSCCPass.h"
#include "llvm/Analysis/LoopInfo.h"
#include "llvm/Analysis/LoopPass.h"
#include "llvm/Analysis/RegionInfo.h"
#include "llvm/Analysis/RegionPass.h"
#include "llvm/IR/BasicBlock.h"
#include "llvm/IR/Function.h"
#include "llvm/Pass.h"
#include "llvm/Support/raw_ostream.h"
#include <string>
using namespace llvm;
namespace {
struct FunctionPassPrinter : public FunctionPass {
const PassInfo *PassToPrint;
raw_ostream &Out;
static char ID;
std::string PassName;
FunctionPassPrinter(const PassInfo *PI, raw_ostream &out)
: FunctionPass(ID), PassToPrint(PI), Out(out) {
std::string PassToPrintName = std::string(PassToPrint->getPassName());
PassName = "FunctionPass Printer: " + PassToPrintName;
}
bool runOnFunction(Function &F) override {
Out << "Printing analysis '" << PassToPrint->getPassName()
<< "' for function '" << F.getName() << "':\n";
// Get and print pass...
getAnalysisID<Pass>(PassToPrint->getTypeInfo()).print(Out, F.getParent());
return false;
}
StringRef getPassName() const override { return PassName; }
void getAnalysisUsage(AnalysisUsage &AU) const override {
AU.addRequiredID(PassToPrint->getTypeInfo());
AU.setPreservesAll();
}
};
char FunctionPassPrinter::ID = 0;
struct CallGraphSCCPassPrinter : public CallGraphSCCPass {
static char ID;
const PassInfo *PassToPrint;
raw_ostream &Out;
std::string PassName;
CallGraphSCCPassPrinter(const PassInfo *PI, raw_ostream &out)
: CallGraphSCCPass(ID), PassToPrint(PI), Out(out) {
std::string PassToPrintName = std::string(PassToPrint->getPassName());
PassName = "CallGraphSCCPass Printer: " + PassToPrintName;
}
bool runOnSCC(CallGraphSCC &SCC) override {
Out << "Printing analysis '" << PassToPrint->getPassName() << "':\n";
// Get and print pass...
for (CallGraphSCC::iterator I = SCC.begin(), E = SCC.end(); I != E; ++I) {
Function *F = (*I)->getFunction();
if (F)
getAnalysisID<Pass>(PassToPrint->getTypeInfo())
.print(Out, F->getParent());
}
return false;
}
StringRef getPassName() const override { return PassName; }
void getAnalysisUsage(AnalysisUsage &AU) const override {
AU.addRequiredID(PassToPrint->getTypeInfo());
AU.setPreservesAll();
}
};
char CallGraphSCCPassPrinter::ID = 0;
struct ModulePassPrinter : public ModulePass {
static char ID;
const PassInfo *PassToPrint;
raw_ostream &Out;
std::string PassName;
ModulePassPrinter(const PassInfo *PI, raw_ostream &out)
: ModulePass(ID), PassToPrint(PI), Out(out) {
std::string PassToPrintName = std::string(PassToPrint->getPassName());
PassName = "ModulePass Printer: " + PassToPrintName;
}
bool runOnModule(Module &M) override {
Out << "Printing analysis '" << PassToPrint->getPassName() << "':\n";
// Get and print pass...
getAnalysisID<Pass>(PassToPrint->getTypeInfo()).print(Out, &M);
return false;
}
StringRef getPassName() const override { return PassName; }
void getAnalysisUsage(AnalysisUsage &AU) const override {
AU.addRequiredID(PassToPrint->getTypeInfo());
AU.setPreservesAll();
}
};
char ModulePassPrinter::ID = 0;
struct LoopPassPrinter : public LoopPass {
static char ID;
const PassInfo *PassToPrint;
raw_ostream &Out;
std::string PassName;
LoopPassPrinter(const PassInfo *PI, raw_ostream &out)
: LoopPass(ID), PassToPrint(PI), Out(out) {
std::string PassToPrintName = std::string(PassToPrint->getPassName());
PassName = "LoopPass Printer: " + PassToPrintName;
}
bool runOnLoop(Loop *L, LPPassManager &LPM) override {
Out << "Printing analysis '" << PassToPrint->getPassName() << "':\n";
// Get and print pass...
getAnalysisID<Pass>(PassToPrint->getTypeInfo())
.print(Out, L->getHeader()->getParent()->getParent());
return false;
}
StringRef getPassName() const override { return PassName; }
void getAnalysisUsage(AnalysisUsage &AU) const override {
AU.addRequiredID(PassToPrint->getTypeInfo());
AU.setPreservesAll();
}
};
char LoopPassPrinter::ID = 0;
struct RegionPassPrinter : public RegionPass {
static char ID;
const PassInfo *PassToPrint;
raw_ostream &Out;
std::string PassName;
RegionPassPrinter(const PassInfo *PI, raw_ostream &out)
: RegionPass(ID), PassToPrint(PI), Out(out) {
std::string PassToPrintName = std::string(PassToPrint->getPassName());
PassName = "RegionPass Printer: " + PassToPrintName;
}
bool runOnRegion(Region *R, RGPassManager &RGM) override {
Out << "Printing analysis '" << PassToPrint->getPassName() << "' for "
<< "region: '" << R->getNameStr() << "' in function '"
<< R->getEntry()->getParent()->getName() << "':\n";
// Get and print pass...
getAnalysisID<Pass>(PassToPrint->getTypeInfo())
.print(Out, R->getEntry()->getParent()->getParent());
return false;
}
StringRef getPassName() const override { return PassName; }
void getAnalysisUsage(AnalysisUsage &AU) const override {
AU.addRequiredID(PassToPrint->getTypeInfo());
AU.setPreservesAll();
}
};
char RegionPassPrinter::ID = 0;
} // end anonymous namespace
FunctionPass *llvm::createFunctionPassPrinter(const PassInfo *PI,
raw_ostream &OS) {
return new FunctionPassPrinter(PI, OS);
}
CallGraphSCCPass *llvm::createCallGraphPassPrinter(const PassInfo *PI,
raw_ostream &OS) {
return new CallGraphSCCPassPrinter(PI, OS);
}
ModulePass *llvm::createModulePassPrinter(const PassInfo *PI, raw_ostream &OS) {
return new ModulePassPrinter(PI, OS);
}
LoopPass *llvm::createLoopPassPrinter(const PassInfo *PI, raw_ostream &OS) {
return new LoopPassPrinter(PI, OS);
}
RegionPass *llvm::createRegionPassPrinter(const PassInfo *PI, raw_ostream &OS) {
return new RegionPassPrinter(PI, OS);
}

40
llvm/tools/opt/PassPrinters.h
View file

@ -1,40 +0,0 @@
//=- PassPrinters.h - Utilities to print analysis info for passes -*- C++ -*-=//
//
// 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
/// Utilities to print analysis info for various kinds of passes.
///
//===----------------------------------------------------------------------===//
#ifndef LLVM_TOOLS_OPT_PASSPRINTERS_H
#define LLVM_TOOLS_OPT_PASSPRINTERS_H
namespace llvm {
class CallGraphSCCPass;
class FunctionPass;
class ModulePass;
class LoopPass;
class PassInfo;
class raw_ostream;
class RegionPass;
FunctionPass *createFunctionPassPrinter(const PassInfo *PI, raw_ostream &out);
CallGraphSCCPass *createCallGraphPassPrinter(const PassInfo *PI,
raw_ostream &out);
ModulePass *createModulePassPrinter(const PassInfo *PI, raw_ostream &out);
LoopPass *createLoopPassPrinter(const PassInfo *PI, raw_ostream &out);
RegionPass *createRegionPassPrinter(const PassInfo *PI, raw_ostream &out);
} // end namespace llvm
#endif // LLVM_TOOLS_OPT_PASSPRINTERS_H

45
llvm/tools/opt/opt.cpp
View file

@ -13,7 +13,6 @@
#include "BreakpointPrinter.h"
#include "NewPMDriver.h"
#include "PassPrinters.h"
#include "llvm/ADT/Triple.h"
#include "llvm/Analysis/CallGraph.h"
#include "llvm/Analysis/CallGraphSCCPass.h"
@ -199,10 +198,6 @@ DisableBuiltins("disable-builtin",
cl::desc("Disable specific target library builtin function"),
cl::ZeroOrMore);
static cl::opt<bool>
AnalyzeOnly("analyze", cl::desc("Only perform analysis, no optimization. "
"Legacy pass manager only."));
static cl::opt<bool> EnableDebugify(
"enable-debugify",
cl::desc(
@ -603,11 +598,6 @@ int main(int argc, char **argv) {
LLVMContext Context;
if (AnalyzeOnly && NoOutput) {
errs() << argv[0] << ": analyze mode conflicts with no-output mode.\n";
return 1;
}
// If `-passes=` is specified, use NPM.
// If `-enable-new-pm` is specified and there are no codegen passes, use NPM.
// e.g. `-enable-new-pm -sroa` will use NPM.
@ -756,7 +746,7 @@ int main(int argc, char **argv) {
// If the output is set to be emitted to standard out, and standard out is a
// console, print out a warning message and refuse to do it. We don't
// impress anyone by spewing tons of binary goo to a terminal.
if (!Force && !NoOutput && !AnalyzeOnly && !OutputAssembly)
if (!Force && !NoOutput && !OutputAssembly)
if (CheckBitcodeOutputToConsole(Out->os()))
NoOutput = true;
@ -783,13 +773,6 @@ int main(int argc, char **argv) {
}
if (UseNPM) {
if (AnalyzeOnly) {
errs() << "Cannot specify -analyze under new pass manager, either "
"specify '-enable-new-pm=0', or use the corresponding new pass "
"manager pass, e.g. '-passes=print<scalar-evolution>'. For a "
"full list of passes, see the '--print-passes' flag.\n";
return 1;
}
if (legacy::debugPassSpecified()) {
errs()
<< "-debug-pass does not work with the new PM, either use "
@ -963,30 +946,8 @@ int main(int argc, char **argv) {
else
errs() << argv[0] << ": cannot create pass: "
<< PassInf->getPassName() << "\n";
if (P) {
PassKind Kind = P->getPassKind();
if (P)
addPass(Passes, P);
if (AnalyzeOnly) {
switch (Kind) {
case PT_Region:
Passes.add(createRegionPassPrinter(PassInf, Out->os()));
break;
case PT_Loop:
Passes.add(createLoopPassPrinter(PassInf, Out->os()));
break;
case PT_Function:
Passes.add(createFunctionPassPrinter(PassInf, Out->os()));
break;
case PT_CallGraphSCC:
Passes.add(createCallGraphPassPrinter(PassInf, Out->os()));
break;
default:
Passes.add(createModulePassPrinter(PassInf, Out->os()));
break;
}
}
}
}
if (OptLevelO0)
@ -1039,7 +1000,7 @@ int main(int argc, char **argv) {
std::unique_ptr<raw_svector_ostream> BOS;
raw_ostream *OS = nullptr;
const bool ShouldEmitOutput = !NoOutput && !AnalyzeOnly;
const bool ShouldEmitOutput = !NoOutput;
// Write bitcode or assembly to the output as the last step...
if (ShouldEmitOutput || RunTwice) {

1
llvm/utils/gn/secondary/llvm/tools/opt/BUILD.gn
View file

@ -24,7 +24,6 @@ executable("opt") {
"BreakpointPrinter.cpp",
"GraphPrinters.cpp",
"NewPMDriver.cpp",
"PassPrinters.cpp",
"PrintSCC.cpp",
"opt.cpp",
]