https://github.com/cristianassaiante updated
https://github.com/llvm/llvm-project/pull/145059
>From ab6063493744ef5a1ee92fd249bf8d86b7299fad Mon Sep 17 00:00:00 2001
From: Cristian Assaiante <cristianassaia...@outlook.com>
Date: Fri, 20 Jun 2025 16:56:23 +0200
Subject: [PATCH 01/11] Adding -opt-disable and a test for it
---
clang/test/CodeGen/opt-disable.c | 13 +++++++
llvm/include/llvm/IR/OptBisect.h | 39 ++++++++++++++++++++
llvm/lib/IR/OptBisect.cpp | 63 ++++++++++++++++++++++++++++++--
3 files changed, 111 insertions(+), 4 deletions(-)
create mode 100644 clang/test/CodeGen/opt-disable.c
diff --git a/clang/test/CodeGen/opt-disable.c b/clang/test/CodeGen/opt-disable.c
new file mode 100644
index 0000000000000..ee90fc5620d65
--- /dev/null
+++ b/clang/test/CodeGen/opt-disable.c
@@ -0,0 +1,13 @@
+// REQUIRES: x86-registered-target
+
+// Make sure opt-bisect works through both pass managers
+//
+// RUN: %clang_cc1 -triple x86_64-linux-gnu -O1 %s -mllvm
-opt-disable="inlinerpass,SROAPass,machine code sinking" -mllvm
-opt-disable-verbose -emit-obj -o /dev/null 2>&1 | FileCheck %s
+
+// CHECK-NOT: DISABLE: running pass InlinerPass
+// CHECK-NOT: DISABLE: running pass SROAPass
+// CHECK-NOT: DISABLE: running pass Machine code sinking
+// Make sure that legacy pass manager is running
+// CHECK: Instruction Selection
+
+int func(int a) { return a; }
diff --git a/llvm/include/llvm/IR/OptBisect.h b/llvm/include/llvm/IR/OptBisect.h
index be6aef3298b23..51c3a8040da9b 100644
--- a/llvm/include/llvm/IR/OptBisect.h
+++ b/llvm/include/llvm/IR/OptBisect.h
@@ -17,6 +17,7 @@
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/Compiler.h"
#include <limits>
+#include <set>
namespace llvm {
@@ -82,6 +83,44 @@ class LLVM_ABI OptBisect : public OptPassGate {
int LastBisectNum = 0;
};
+/// This class implements a mechanism to disable passes and individual
+/// optimizations at compile time based on a command line option
+/// (-opt-disable) in order to study how single transformations, or
+/// combinations thereof, affect the IR.
+class LLVM_ABI OptDisable : public OptPassGate {
+public:
+ /// Default constructor. Initializes the state to empty set. The disabling
+ /// will be enabled by the cl::opt call-back when the command line option
+ /// is processed.
+ /// Clients should not instantiate this class directly. All access should go
+ /// through LLVMContext.
+ OptDisable() = default;
+
+ virtual ~OptDisable() = default;
+
+ /// Checks the pass name to determine if the specified pass should run.
+ ///
+ /// The method prints the name of the pass, and whether or not the pass
+ /// will be executed. It returns true if the pass should run, i.e. if
+ /// its name is was not provided via command line.
+ ///
+ /// Most passes should not call this routine directly. Instead, it is called
+ /// through helper routines provided by the base classes of the pass. For
+ /// instance, function passes should call FunctionPass::skipFunction().
+ bool shouldRunPass(const StringRef PassName,
+ StringRef IRDescription) override;
+
+ /// Parses the command line argument to extract the names of the passes
+ /// to be disabled. Multiple pass names can be provided with comma
separation.
+ void setDisabled(StringRef Passes);
+
+ /// isEnabled() should return true before calling shouldRunPass().
+ bool isEnabled() const override { return !DisabledPasses.empty(); }
+
+private:
+ std::set<std::string> DisabledPasses = {};
+};
+
/// Singleton instance of the OptBisect class, so multiple pass managers don't
/// need to coordinate their uses of OptBisect.
LLVM_ABI OptPassGate &getGlobalPassGate();
diff --git a/llvm/lib/IR/OptBisect.cpp b/llvm/lib/IR/OptBisect.cpp
index 559b199445366..aa1dbdfdbebd4 100644
--- a/llvm/lib/IR/OptBisect.cpp
+++ b/llvm/lib/IR/OptBisect.cpp
@@ -17,6 +17,7 @@
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/raw_ostream.h"
#include <cassert>
+#include <sstream>
using namespace llvm;
@@ -37,8 +38,8 @@ static cl::opt<bool> OptBisectVerbose(
cl::desc("Show verbose output when opt-bisect-limit is set"), cl::Hidden,
cl::init(true), cl::Optional);
-static void printPassMessage(const StringRef &Name, int PassNum,
- StringRef TargetDesc, bool Running) {
+static void printBisectPassMessage(const StringRef &Name, int PassNum,
+ StringRef TargetDesc, bool Running) {
StringRef Status = Running ? "" : "NOT ";
errs() << "BISECT: " << Status << "running pass "
<< "(" << PassNum << ") " << Name << " on " << TargetDesc << "\n";
@@ -51,10 +52,64 @@ bool OptBisect::shouldRunPass(const StringRef PassName,
int CurBisectNum = ++LastBisectNum;
bool ShouldRun = (BisectLimit == -1 || CurBisectNum <= BisectLimit);
if (OptBisectVerbose)
- printPassMessage(PassName, CurBisectNum, IRDescription, ShouldRun);
+ printBisectPassMessage(PassName, CurBisectNum, IRDescription, ShouldRun);
return ShouldRun;
}
const int OptBisect::Disabled;
-OptPassGate &llvm::getGlobalPassGate() { return getOptBisector(); }
+static OptDisable &getOptDisabler() {
+ static OptDisable OptDisabler;
+ return OptDisabler;
+}
+
+static cl::opt<std::string> OptDisablePass(
+ "opt-disable", cl::Hidden, cl::init(""), cl::Optional,
+ cl::cb<void, std::string>([](std::string Passes) {
+ getOptDisabler().setDisabled(Passes);
+ }),
+ cl::desc("Optimization pass(es) to disable (comma separated)"));
+
+static cl::opt<bool>
+ OptDisableVerbose("opt-disable-verbose",
+ cl::desc("Show verbose output when opt-disable is set"),
+ cl::Hidden, cl::init(false), cl::Optional);
+
+static void printDisablePassMessage(const StringRef &Name, StringRef
TargetDesc,
+ bool Running) {
+ StringRef Status = Running ? "" : "NOT ";
+ errs() << "DISABLE: " << Status << "running pass " << Name << " on "
+ << TargetDesc << "\n";
+}
+
+void OptDisable::setDisabled(StringRef Passes) {
+ std::stringstream StrStream(Passes.str());
+ std::string Token;
+
+ while (std::getline(StrStream, Token, ',')) {
+ if (!Token.empty()) {
+ std::transform(Token.begin(), Token.end(), Token.begin(), ::tolower);
+ DisabledPasses.insert(Token);
+ }
+ }
+}
+
+bool OptDisable::shouldRunPass(const StringRef PassName,
+ StringRef IRDescription) {
+ assert(isEnabled());
+
+ std::string LowerName = PassName.str();
+ std::transform(LowerName.begin(), LowerName.end(), LowerName.begin(),
+ ::tolower);
+
+ bool ShouldRun = DisabledPasses.find(LowerName) == DisabledPasses.end();
+ if (OptDisableVerbose)
+ printDisablePassMessage(PassName, IRDescription, ShouldRun);
+ return ShouldRun;
+}
+
+OptPassGate &llvm::getGlobalPassGate() {
+ if (getOptDisabler().isEnabled())
+ return getOptDisabler();
+ return getOptBisector();
+}
>From 5e79702e3bcee337ced764967d95cb3c684b7fa8 Mon Sep 17 00:00:00 2001
From: Cristian Assaiante <cristianassaia...@outlook.com>
Date: Mon, 23 Jun 2025 11:08:02 +0200
Subject: [PATCH 02/11] Partial solve of review comments
---
llvm/include/llvm/IR/OptBisect.h | 4 ++--
llvm/lib/IR/OptBisect.cpp | 21 +++++++--------------
2 files changed, 9 insertions(+), 16 deletions(-)
diff --git a/llvm/include/llvm/IR/OptBisect.h b/llvm/include/llvm/IR/OptBisect.h
index 51c3a8040da9b..20d332d78a8e5 100644
--- a/llvm/include/llvm/IR/OptBisect.h
+++ b/llvm/include/llvm/IR/OptBisect.h
@@ -15,9 +15,9 @@
#define LLVM_IR_OPTBISECT_H
#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/StringSet.h"
#include "llvm/Support/Compiler.h"
#include <limits>
-#include <set>
namespace llvm {
@@ -118,7 +118,7 @@ class LLVM_ABI OptDisable : public OptPassGate {
bool isEnabled() const override { return !DisabledPasses.empty(); }
private:
- std::set<std::string> DisabledPasses = {};
+ StringSet<> DisabledPasses = {};
};
/// Singleton instance of the OptBisect class, so multiple pass managers don't
diff --git a/llvm/lib/IR/OptBisect.cpp b/llvm/lib/IR/OptBisect.cpp
index aa1dbdfdbebd4..5adad939deab6 100644
--- a/llvm/lib/IR/OptBisect.cpp
+++ b/llvm/lib/IR/OptBisect.cpp
@@ -17,7 +17,6 @@
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/raw_ostream.h"
#include <cassert>
-#include <sstream>
using namespace llvm;
@@ -83,14 +82,12 @@ static void printDisablePassMessage(const StringRef &Name,
StringRef TargetDesc,
}
void OptDisable::setDisabled(StringRef Passes) {
- std::stringstream StrStream(Passes.str());
- std::string Token;
-
- while (std::getline(StrStream, Token, ',')) {
- if (!Token.empty()) {
- std::transform(Token.begin(), Token.end(), Token.begin(), ::tolower);
- DisabledPasses.insert(Token);
- }
+ llvm::SmallVector<llvm::StringRef, 8> Tokens;
+
+ Passes.split(Tokens, ',', -1, false);
+
+ for (auto Token : Tokens) {
+ DisabledPasses.insert(Token.lower());
}
}
@@ -98,11 +95,7 @@ bool OptDisable::shouldRunPass(const StringRef PassName,
StringRef IRDescription) {
assert(isEnabled());
- std::string LowerName = PassName.str();
- std::transform(LowerName.begin(), LowerName.end(), LowerName.begin(),
- ::tolower);
-
- bool ShouldRun = DisabledPasses.find(LowerName) == DisabledPasses.end();
+ bool ShouldRun = !DisabledPasses.contains(PassName.lower());
if (OptDisableVerbose)
printDisablePassMessage(PassName, IRDescription, ShouldRun);
return ShouldRun;
>From 88625075b9854ad7fabe0007b0bc0b44f8d91f58 Mon Sep 17 00:00:00 2001
From: Cristian Assaiante <cristianassaia...@outlook.com>
Date: Mon, 23 Jun 2025 12:33:05 +0200
Subject: [PATCH 03/11] Fix vector usage
---
llvm/lib/IR/OptBisect.cpp | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/llvm/lib/IR/OptBisect.cpp b/llvm/lib/IR/OptBisect.cpp
index 5adad939deab6..a2591e07f0a00 100644
--- a/llvm/lib/IR/OptBisect.cpp
+++ b/llvm/lib/IR/OptBisect.cpp
@@ -65,6 +65,7 @@ static OptDisable &getOptDisabler() {
static cl::opt<std::string> OptDisablePass(
"opt-disable", cl::Hidden, cl::init(""), cl::Optional,
cl::cb<void, std::string>([](std::string Passes) {
+ getOptDisabler().initMap();
getOptDisabler().setDisabled(Passes);
}),
cl::desc("Optimization pass(es) to disable (comma separated)"));
@@ -82,7 +83,7 @@ static void printDisablePassMessage(const StringRef &Name,
StringRef TargetDesc,
}
void OptDisable::setDisabled(StringRef Passes) {
- llvm::SmallVector<llvm::StringRef, 8> Tokens;
+ llvm::SmallVector<llvm::StringRef, 4> Tokens;
Passes.split(Tokens, ',', -1, false);
>From 9f95327b2b772d24b73f32164e8dad2e889d8847 Mon Sep 17 00:00:00 2001
From: Cristian Assaiante <cristianassaia...@outlook.com>
Date: Mon, 23 Jun 2025 19:23:15 +0200
Subject: [PATCH 04/11] Remove leftovers
---
llvm/lib/IR/OptBisect.cpp | 1 -
1 file changed, 1 deletion(-)
diff --git a/llvm/lib/IR/OptBisect.cpp b/llvm/lib/IR/OptBisect.cpp
index a2591e07f0a00..db068633454b5 100644
--- a/llvm/lib/IR/OptBisect.cpp
+++ b/llvm/lib/IR/OptBisect.cpp
@@ -65,7 +65,6 @@ static OptDisable &getOptDisabler() {
static cl::opt<std::string> OptDisablePass(
"opt-disable", cl::Hidden, cl::init(""), cl::Optional,
cl::cb<void, std::string>([](std::string Passes) {
- getOptDisabler().initMap();
getOptDisabler().setDisabled(Passes);
}),
cl::desc("Optimization pass(es) to disable (comma separated)"));
>From 56405f21193edb70d4c55b14bc8fa54e7fb96b3e Mon Sep 17 00:00:00 2001
From: Cristian Assaiante <cristianassaia...@outlook.com>
Date: Fri, 27 Jun 2025 19:07:03 +0200
Subject: [PATCH 05/11] Converted to cl::list, renamed verbose flag, cleanup
---
llvm/include/llvm/IR/OptBisect.h | 15 ++++++++-------
llvm/lib/IR/OptBisect.cpp | 28 +++++++++++-----------------
2 files changed, 19 insertions(+), 24 deletions(-)
diff --git a/llvm/include/llvm/IR/OptBisect.h b/llvm/include/llvm/IR/OptBisect.h
index 20d332d78a8e5..83d3579225b1a 100644
--- a/llvm/include/llvm/IR/OptBisect.h
+++ b/llvm/include/llvm/IR/OptBisect.h
@@ -90,7 +90,7 @@ class LLVM_ABI OptBisect : public OptPassGate {
class LLVM_ABI OptDisable : public OptPassGate {
public:
/// Default constructor. Initializes the state to empty set. The disabling
- /// will be enabled by the cl::opt call-back when the command line option
+ /// will be enabled by the cl::list call-back when the command line option
/// is processed.
/// Clients should not instantiate this class directly. All access should go
/// through LLVMContext.
@@ -100,9 +100,10 @@ class LLVM_ABI OptDisable : public OptPassGate {
/// Checks the pass name to determine if the specified pass should run.
///
- /// The method prints the name of the pass, and whether or not the pass
- /// will be executed. It returns true if the pass should run, i.e. if
- /// its name is was not provided via command line.
+ /// It returns true if the pass should run, i.e. if its name is was
+ /// not provided via command line.
+ /// If -opt-disable-enable-verbosity is given, the method prints the
+ /// name of the pass, and whether or not the pass will be executed.
///
/// Most passes should not call this routine directly. Instead, it is called
/// through helper routines provided by the base classes of the pass. For
@@ -112,7 +113,7 @@ class LLVM_ABI OptDisable : public OptPassGate {
/// Parses the command line argument to extract the names of the passes
/// to be disabled. Multiple pass names can be provided with comma
separation.
- void setDisabled(StringRef Passes);
+ void setDisabled(StringRef Pass);
/// isEnabled() should return true before calling shouldRunPass().
bool isEnabled() const override { return !DisabledPasses.empty(); }
@@ -121,8 +122,8 @@ class LLVM_ABI OptDisable : public OptPassGate {
StringSet<> DisabledPasses = {};
};
-/// Singleton instance of the OptBisect class, so multiple pass managers don't
-/// need to coordinate their uses of OptBisect.
+/// Singleton instance of the OptPassGate class, so multiple pass managers
don't
+/// need to coordinate their uses of OptBisect and OptDisable.
LLVM_ABI OptPassGate &getGlobalPassGate();
} // end namespace llvm
diff --git a/llvm/lib/IR/OptBisect.cpp b/llvm/lib/IR/OptBisect.cpp
index db068633454b5..dc5637a31c08b 100644
--- a/llvm/lib/IR/OptBisect.cpp
+++ b/llvm/lib/IR/OptBisect.cpp
@@ -37,8 +37,8 @@ static cl::opt<bool> OptBisectVerbose(
cl::desc("Show verbose output when opt-bisect-limit is set"), cl::Hidden,
cl::init(true), cl::Optional);
-static void printBisectPassMessage(const StringRef &Name, int PassNum,
- StringRef TargetDesc, bool Running) {
+static void printPassMessage(const StringRef &Name, int PassNum,
+ StringRef TargetDesc, bool Running) {
StringRef Status = Running ? "" : "NOT ";
errs() << "BISECT: " << Status << "running pass "
<< "(" << PassNum << ") " << Name << " on " << TargetDesc << "\n";
@@ -51,7 +51,7 @@ bool OptBisect::shouldRunPass(const StringRef PassName,
int CurBisectNum = ++LastBisectNum;
bool ShouldRun = (BisectLimit == -1 || CurBisectNum <= BisectLimit);
if (OptBisectVerbose)
- printBisectPassMessage(PassName, CurBisectNum, IRDescription, ShouldRun);
+ printPassMessage(PassName, CurBisectNum, IRDescription, ShouldRun);
return ShouldRun;
}
@@ -62,15 +62,15 @@ static OptDisable &getOptDisabler() {
return OptDisabler;
}
-static cl::opt<std::string> OptDisablePass(
- "opt-disable", cl::Hidden, cl::init(""), cl::Optional,
- cl::cb<void, std::string>([](std::string Passes) {
- getOptDisabler().setDisabled(Passes);
+static cl::list<std::string> OptDisablePasses(
+ "opt-disable", cl::Hidden, cl::CommaSeparated, cl::Optional,
+ cl::cb<void, std::string>([](std::string Pass) {
+ getOptDisabler().setDisabled(Pass);
}),
- cl::desc("Optimization pass(es) to disable (comma separated)"));
+ cl::desc("Optimization pass(es) to disable (comma-separated list)"));
static cl::opt<bool>
- OptDisableVerbose("opt-disable-verbose",
+ OptDisableVerbose("opt-disable-enable-verbosity",
cl::desc("Show verbose output when opt-disable is set"),
cl::Hidden, cl::init(false), cl::Optional);
@@ -81,14 +81,8 @@ static void printDisablePassMessage(const StringRef &Name,
StringRef TargetDesc,
<< TargetDesc << "\n";
}
-void OptDisable::setDisabled(StringRef Passes) {
- llvm::SmallVector<llvm::StringRef, 4> Tokens;
-
- Passes.split(Tokens, ',', -1, false);
-
- for (auto Token : Tokens) {
- DisabledPasses.insert(Token.lower());
- }
+void OptDisable::setDisabled(StringRef Pass) {
+ DisabledPasses.insert(Pass.lower());
}
bool OptDisable::shouldRunPass(const StringRef PassName,
>From 731bcdf9b93eea1345a269257fe3ef6ee9cc37a0 Mon Sep 17 00:00:00 2001
From: Cristian Assaiante <cristianassaia...@outlook.com>
Date: Thu, 3 Jul 2025 01:41:22 +0200
Subject: [PATCH 06/11] Fixes, new test using opt in llvm/test
---
clang/test/CodeGen/opt-disable.c | 13 -----
llvm/include/llvm/IR/OptBisect.h | 15 ++----
llvm/lib/IR/OptBisect.cpp | 2 +-
llvm/test/Other/opt-disable.ll | 89 ++++++++++++++++++++++++++++++++
4 files changed, 93 insertions(+), 26 deletions(-)
delete mode 100644 clang/test/CodeGen/opt-disable.c
create mode 100644 llvm/test/Other/opt-disable.ll
diff --git a/clang/test/CodeGen/opt-disable.c b/clang/test/CodeGen/opt-disable.c
deleted file mode 100644
index ee90fc5620d65..0000000000000
--- a/clang/test/CodeGen/opt-disable.c
+++ /dev/null
@@ -1,13 +0,0 @@
-// REQUIRES: x86-registered-target
-
-// Make sure opt-bisect works through both pass managers
-//
-// RUN: %clang_cc1 -triple x86_64-linux-gnu -O1 %s -mllvm
-opt-disable="inlinerpass,SROAPass,machine code sinking" -mllvm
-opt-disable-verbose -emit-obj -o /dev/null 2>&1 | FileCheck %s
-
-// CHECK-NOT: DISABLE: running pass InlinerPass
-// CHECK-NOT: DISABLE: running pass SROAPass
-// CHECK-NOT: DISABLE: running pass Machine code sinking
-// Make sure that legacy pass manager is running
-// CHECK: Instruction Selection
-
-int func(int a) { return a; }
diff --git a/llvm/include/llvm/IR/OptBisect.h b/llvm/include/llvm/IR/OptBisect.h
index a0a6d2532748f..d5b2ece1f84bb 100644
--- a/llvm/include/llvm/IR/OptBisect.h
+++ b/llvm/include/llvm/IR/OptBisect.h
@@ -89,27 +89,18 @@ class LLVM_ABI OptBisect : public OptPassGate {
/// combinations thereof, affect the IR.
class LLVM_ABI OptDisable : public OptPassGate {
public:
- /// Default constructor. Initializes the state to empty set. The disabling
- /// will be enabled by the cl::list call-back when the command line option
- /// is processed.
- /// Clients should not instantiate this class directly. All access should go
- /// through LLVMContext.
- OptDisable() = default;
-
- virtual ~OptDisable() = default;
-
/// Checks the pass name to determine if the specified pass should run.
///
- /// It returns true if the pass should run, i.e. if its name is was
+ /// It returns true if the pass should run, i.e. if its name is was
/// not provided via command line.
- /// If -opt-disable-enable-verbosity is given, the method prints the
+ /// If -opt-disable-enable-verbosity is given, the method prints the
/// name of the pass, and whether or not the pass will be executed.
///
/// Most passes should not call this routine directly. Instead, it is called
/// through helper routines provided by the base classes of the pass. For
/// instance, function passes should call FunctionPass::skipFunction().
bool shouldRunPass(const StringRef PassName,
- StringRef IRDescription) override;
+ StringRef IRDescription) const override;
/// Parses the command line argument to extract the names of the passes
/// to be disabled. Multiple pass names can be provided with comma
separation.
diff --git a/llvm/lib/IR/OptBisect.cpp b/llvm/lib/IR/OptBisect.cpp
index f83241f9903e7..471a9cfdc1491 100644
--- a/llvm/lib/IR/OptBisect.cpp
+++ b/llvm/lib/IR/OptBisect.cpp
@@ -86,7 +86,7 @@ void OptDisable::setDisabled(StringRef Pass) {
}
bool OptDisable::shouldRunPass(const StringRef PassName,
- StringRef IRDescription) {
+ StringRef IRDescription) const {
assert(isEnabled());
bool ShouldRun = !DisabledPasses.contains(PassName.lower());
diff --git a/llvm/test/Other/opt-disable.ll b/llvm/test/Other/opt-disable.ll
new file mode 100644
index 0000000000000..0b1a0b08a5a8b
--- /dev/null
+++ b/llvm/test/Other/opt-disable.ll
@@ -0,0 +1,89 @@
+; RUN: opt -disable-output -disable-verify \
+; RUN: -opt-disable-enable-verbosity \
+; RUN: -passes=inferattrs -opt-disable=inferfunctionattrspass %s 2>&1 \
+; RUN: | FileCheck %s --check-prefix=CHECK-MODULE-PASS
+; CHECK-MODULE-PASS: DISABLE: NOT running pass InferFunctionAttrsPass on
[module]
+
+; RUN: opt -disable-output -disable-verify \
+; RUN: -opt-disable-enable-verbosity \
+; RUN: -passes=sroa -opt-disable=sroapass %s 2>&1 \
+; RUN: | FileCheck %s --check-prefix=CHECK-FUNCTION-PASS
+; CHECK-FUNCTION-PASS: DISABLE: NOT running pass SROAPass on f1
+; CHECK-FUNCTION-PASS: DISABLE: NOT running pass SROAPass on f2
+; CHECK-FUNCTION-PASS: DISABLE: NOT running pass SROAPass on f3
+; CHECK-FUNCTION-PASS: DISABLE: NOT running pass SROAPass on f4
+
+; RUN: opt -disable-output -disable-verify \
+; RUN: -opt-disable=inferfunctionattrspass,PostOrderFunctionAttrsPass \
+; RUN: -opt-disable-enable-verbosity \
+; RUN: -passes='inferattrs,cgscc(function-attrs,function(early-cse))' %s
2>&1 \
+; RUN: | FileCheck %s --check-prefix=CHECK-MULTI-PASS
+; CHECK-MULTI-PASS: DISABLE: NOT running pass InferFunctionAttrsPass on
[module]
+; CHECK-MULTI-PASS: DISABLE: NOT running pass PostOrderFunctionAttrsPass on
(f1)
+; CHECK-MULTI-PASS: DISABLE: running pass EarlyCSEPass on f1
+; CHECK-MULTI-PASS: DISABLE: NOT running pass PostOrderFunctionAttrsPass on
(f2)
+; CHECK-MULTI-PASS: DISABLE: running pass EarlyCSEPass on f2
+; CHECK-MULTI-PASS: DISABLE: NOT running pass PostOrderFunctionAttrsPass on
(f3)
+; CHECK-MULTI-PASS: DISABLE: running pass EarlyCSEPass on f3
+; CHECK-MULTI-PASS: DISABLE: NOT running pass PostOrderFunctionAttrsPass on
(f4)
+; CHECK-MULTI-PASS: DISABLE: running pass EarlyCSEPass on f4
+
+declare i32 @g()
+
+define void @f1(i1 %arg) {
+entry:
+ br label %loop.0
+loop.0:
+ br i1 %arg, label %loop.0.0, label %loop.1
+loop.0.0:
+ br i1 %arg, label %loop.0.0, label %loop.0.1
+loop.0.1:
+ br i1 %arg, label %loop.0.1, label %loop.0
+loop.1:
+ br i1 %arg, label %loop.1, label %loop.1.bb1
+loop.1.bb1:
+ br i1 %arg, label %loop.1, label %loop.1.bb2
+loop.1.bb2:
+ br i1 %arg, label %end, label %loop.1.0
+loop.1.0:
+ br i1 %arg, label %loop.1.0, label %loop.1
+end:
+ ret void
+}
+
+define i32 @f2() {
+entry:
+ ret i32 0
+}
+
+define i32 @f3() {
+entry:
+ %temp = call i32 @g()
+ %icmp = icmp ugt i32 %temp, 2
+ br i1 %icmp, label %bb.true, label %bb.false
+bb.true:
+ %temp2 = call i32 @f2()
+ ret i32 %temp2
+bb.false:
+ ret i32 0
+}
+
+; This function is here to verify that opt-bisect can skip all passes for
+; functions that contain lifetime intrinsics.
+define void @f4(i1 %arg) {
+entry:
+ %i = alloca i32, align 4
+ call void @llvm.lifetime.start(i64 4, ptr %i)
+ br label %for.cond
+
+for.cond:
+ br i1 %arg, label %for.body, label %for.end
+
+for.body:
+ br label %for.cond
+
+for.end:
+ ret void
+}
+
+declare void @llvm.lifetime.start(i64, ptr nocapture)
\ No newline at end of file
>From 12bb09c24b4ac487a48b59f8a3ee5ba3e7a61d50 Mon Sep 17 00:00:00 2001
From: Cristian Assaiante <cristianassaia...@outlook.com>
Date: Thu, 3 Jul 2025 01:53:33 +0200
Subject: [PATCH 07/11] Added test description
---
llvm/test/Other/opt-disable.ll | 8 +++++---
1 file changed, 5 insertions(+), 3 deletions(-)
diff --git a/llvm/test/Other/opt-disable.ll b/llvm/test/Other/opt-disable.ll
index 0b1a0b08a5a8b..63d59c5792d3f 100644
--- a/llvm/test/Other/opt-disable.ll
+++ b/llvm/test/Other/opt-disable.ll
@@ -1,3 +1,7 @@
+; This test uses the same IR functions of the opt-bisect test
+; but it checks the correctness of the -opt-disable flag.
+; -opt-disable-enable-verbosity is required to have output.
+
; RUN: opt -disable-output -disable-verify \
; RUN: -opt-disable-enable-verbosity \
; RUN: -passes=inferattrs -opt-disable=inferfunctionattrspass %s 2>&1 \
@@ -68,8 +72,6 @@ bb.false:
ret i32 0
}
-; This function is here to verify that opt-bisect can skip all passes for
-; functions that contain lifetime intrinsics.
define void @f4(i1 %arg) {
entry:
%i = alloca i32, align 4
@@ -86,4 +88,4 @@ for.end:
ret void
}
-declare void @llvm.lifetime.start(i64, ptr nocapture)
\ No newline at end of file
+declare void @llvm.lifetime.start(i64, ptr nocapture)
>From 6cc429b97977b06208548b8cc839f46312b75178 Mon Sep 17 00:00:00 2001
From: Cristian Assaiante <cristianassaia...@outlook.com>
Date: Thu, 3 Jul 2025 10:28:05 +0200
Subject: [PATCH 08/11] Removing leftovers, solving nits
---
llvm/include/llvm/IR/OptBisect.h | 2 +-
llvm/lib/IR/OptBisect.cpp | 40 +++++++++++++++-----------------
2 files changed, 20 insertions(+), 22 deletions(-)
diff --git a/llvm/include/llvm/IR/OptBisect.h b/llvm/include/llvm/IR/OptBisect.h
index d5b2ece1f84bb..d813ae933d65e 100644
--- a/llvm/include/llvm/IR/OptBisect.h
+++ b/llvm/include/llvm/IR/OptBisect.h
@@ -99,7 +99,7 @@ class LLVM_ABI OptDisable : public OptPassGate {
/// Most passes should not call this routine directly. Instead, it is called
/// through helper routines provided by the base classes of the pass. For
/// instance, function passes should call FunctionPass::skipFunction().
- bool shouldRunPass(const StringRef PassName,
+ bool shouldRunPass(StringRef PassName,
StringRef IRDescription) const override;
/// Parses the command line argument to extract the names of the passes
diff --git a/llvm/lib/IR/OptBisect.cpp b/llvm/lib/IR/OptBisect.cpp
index 471a9cfdc1491..9f2a844f13762 100644
--- a/llvm/lib/IR/OptBisect.cpp
+++ b/llvm/lib/IR/OptBisect.cpp
@@ -25,6 +25,11 @@ static OptBisect &getOptBisector() {
return OptBisector;
}
+static OptDisable &getOptDisabler() {
+ static OptDisable OptDisabler;
+ return OptDisabler;
+}
+
static cl::opt<int> OptBisectLimit("opt-bisect-limit", cl::Hidden,
cl::init(OptBisect::Disabled), cl::Optional,
cl::cb<void, int>([](int Limit) {
@@ -37,6 +42,18 @@ static cl::opt<bool> OptBisectVerbose(
cl::desc("Show verbose output when opt-bisect-limit is set"), cl::Hidden,
cl::init(true), cl::Optional);
+static cl::list<std::string> OptDisablePasses(
+ "opt-disable", cl::Hidden, cl::CommaSeparated, cl::Optional,
+ cl::cb<void, std::string>([](std::string Pass) {
+ getOptDisabler().setDisabled(Pass);
+ }),
+ cl::desc("Optimization pass(es) to disable (comma-separated list)"));
+
+static cl::opt<bool>
+ OptDisableVerbose("opt-disable-enable-verbosity",
+ cl::desc("Show verbose output when opt-disable is set"),
+ cl::Hidden, cl::init(false), cl::Optional);
+
static void printPassMessage(StringRef Name, int PassNum, StringRef TargetDesc,
bool Running) {
StringRef Status = Running ? "" : "NOT ";
@@ -55,29 +72,10 @@ bool OptBisect::shouldRunPass(StringRef PassName,
return ShouldRun;
}
-const int OptBisect::Disabled;
-
-static OptDisable &getOptDisabler() {
- static OptDisable OptDisabler;
- return OptDisabler;
-}
-
-static cl::list<std::string> OptDisablePasses(
- "opt-disable", cl::Hidden, cl::CommaSeparated, cl::Optional,
- cl::cb<void, std::string>([](std::string Pass) {
- getOptDisabler().setDisabled(Pass);
- }),
- cl::desc("Optimization pass(es) to disable (comma-separated list)"));
-
-static cl::opt<bool>
- OptDisableVerbose("opt-disable-enable-verbosity",
- cl::desc("Show verbose output when opt-disable is set"),
- cl::Hidden, cl::init(false), cl::Optional);
-
static void printDisablePassMessage(const StringRef &Name, StringRef
TargetDesc,
bool Running) {
StringRef Status = Running ? "" : "NOT ";
- errs() << "DISABLE: " << Status << "running pass " << Name << " on "
+ dbgs() << "DISABLE: " << Status << "running pass " << Name << " on "
<< TargetDesc << "\n";
}
@@ -85,7 +83,7 @@ void OptDisable::setDisabled(StringRef Pass) {
DisabledPasses.insert(Pass.lower());
}
-bool OptDisable::shouldRunPass(const StringRef PassName,
+bool OptDisable::shouldRunPass(StringRef PassName,
StringRef IRDescription) const {
assert(isEnabled());
>From 825b711b36281e1583fa9dfb8ce86fc514d96fa6 Mon Sep 17 00:00:00 2001
From: Cristian Assaiante <assaia...@diag.uniroma1.it>
Date: Thu, 10 Jul 2025 01:35:42 +0200
Subject: [PATCH 09/11] Update llvm/lib/IR/OptBisect.cpp
Co-authored-by: Nikita Popov <git...@npopov.com>
---
llvm/lib/IR/OptBisect.cpp | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/llvm/lib/IR/OptBisect.cpp b/llvm/lib/IR/OptBisect.cpp
index 9f2a844f13762..c3f642accb21b 100644
--- a/llvm/lib/IR/OptBisect.cpp
+++ b/llvm/lib/IR/OptBisect.cpp
@@ -44,7 +44,7 @@ static cl::opt<bool> OptBisectVerbose(
static cl::list<std::string> OptDisablePasses(
"opt-disable", cl::Hidden, cl::CommaSeparated, cl::Optional,
- cl::cb<void, std::string>([](std::string Pass) {
+ cl::cb<void, std::string>([](const std::string &Pass) {
getOptDisabler().setDisabled(Pass);
}),
cl::desc("Optimization pass(es) to disable (comma-separated list)"));
>From c2562c7c0cc6d5425df1fd740354651c6849957c Mon Sep 17 00:00:00 2001
From: Cristian Assaiante <cristianassaia...@outlook.com>
Date: Thu, 10 Jul 2025 09:36:32 +0200
Subject: [PATCH 10/11] Short names with both NPM and Legacy, updated test,
solved nits
---
llvm/include/llvm/Pass.h | 24 +--
llvm/lib/IR/OptBisect.cpp | 4 +-
llvm/lib/IR/Pass.cpp | 46 +++--
llvm/lib/Passes/StandardInstrumentations.cpp | 182 ++++++++++---------
llvm/test/Other/opt-disable.ll | 34 ++--
5 files changed, 152 insertions(+), 138 deletions(-)
diff --git a/llvm/include/llvm/Pass.h b/llvm/include/llvm/Pass.h
index 2ecd47dd10bde..fc5d7410809a7 100644
--- a/llvm/include/llvm/Pass.h
+++ b/llvm/include/llvm/Pass.h
@@ -97,7 +97,7 @@ const char *to_string(ThinOrFullLTOPhase Phase);
/// constrained passes described below.
///
class LLVM_ABI Pass {
- AnalysisResolver *Resolver = nullptr; // Used to resolve analysis
+ AnalysisResolver *Resolver = nullptr; // Used to resolve analysis
const void *PassID;
PassKind Kind;
@@ -114,14 +114,16 @@ class LLVM_ABI Pass {
/// Registration templates, but can be overloaded directly.
virtual StringRef getPassName() const;
+ /// getPassArgument - Return a nice clean name for a pass
+ /// corresponding to that used to enable the pass in opt
+ virtual StringRef getPassArgument() const;
+
/// getPassID - Return the PassID number that corresponds to this pass.
- AnalysisID getPassID() const {
- return PassID;
- }
+ AnalysisID getPassID() const { return PassID; }
/// doInitialization - Virtual method overridden by subclasses to do
/// any necessary initialization before any pass is run.
- virtual bool doInitialization(Module &) { return false; }
+ virtual bool doInitialization(Module &) { return false; }
/// doFinalization - Virtual method overriden by subclasses to do any
/// necessary clean up after all passes have run.
@@ -144,8 +146,7 @@ class LLVM_ABI Pass {
/// Each pass is responsible for assigning a pass manager to itself.
/// PMS is the stack of available pass manager.
- virtual void assignPassManager(PMStack &,
- PassManagerType) {}
+ virtual void assignPassManager(PMStack &, PassManagerType) {}
/// Check if available pass managers are suitable for this pass or not.
virtual void preparePassManager(PMStack &);
@@ -204,8 +205,9 @@ class LLVM_ABI Pass {
/// the case when the analysis is not available. This method is often used
by
/// transformation APIs to update analysis results for a pass automatically
as
/// the transform is performed.
- template<typename AnalysisType> AnalysisType *
- getAnalysisIfAvailable() const; // Defined in PassAnalysisSupport.h
+ template <typename AnalysisType>
+ AnalysisType *
+ getAnalysisIfAvailable() const; // Defined in PassAnalysisSupport.h
/// mustPreserveAnalysisID - This method serves the same function as
/// getAnalysisIfAvailable, but works if you just have an AnalysisID. This
@@ -217,7 +219,7 @@ class LLVM_ABI Pass {
/// getAnalysis<AnalysisType>() - This function is used by subclasses to get
/// to the analysis information that they claim to use by overriding the
/// getAnalysisUsage function.
- template<typename AnalysisType>
+ template <typename AnalysisType>
AnalysisType &getAnalysis() const; // Defined in PassAnalysisSupport.h
template <typename AnalysisType>
@@ -225,7 +227,7 @@ class LLVM_ABI Pass {
getAnalysis(Function &F,
bool *Changed = nullptr); // Defined in PassAnalysisSupport.h
- template<typename AnalysisType>
+ template <typename AnalysisType>
AnalysisType &getAnalysisID(AnalysisID PI) const;
template <typename AnalysisType>
diff --git a/llvm/lib/IR/OptBisect.cpp b/llvm/lib/IR/OptBisect.cpp
index c3f642accb21b..2a60e83688576 100644
--- a/llvm/lib/IR/OptBisect.cpp
+++ b/llvm/lib/IR/OptBisect.cpp
@@ -75,7 +75,7 @@ bool OptBisect::shouldRunPass(StringRef PassName,
static void printDisablePassMessage(const StringRef &Name, StringRef
TargetDesc,
bool Running) {
StringRef Status = Running ? "" : "NOT ";
- dbgs() << "DISABLE: " << Status << "running pass " << Name << " on "
+ dbgs() << "OptDisable: " << Status << "running pass " << Name << " on "
<< TargetDesc << "\n";
}
@@ -87,7 +87,7 @@ bool OptDisable::shouldRunPass(StringRef PassName,
StringRef IRDescription) const {
assert(isEnabled());
- bool ShouldRun = !DisabledPasses.contains(PassName.lower());
+ const bool ShouldRun = !DisabledPasses.contains(PassName.lower());
if (OptDisableVerbose)
printDisablePassMessage(PassName, IRDescription, ShouldRun);
return ShouldRun;
diff --git a/llvm/lib/IR/Pass.cpp b/llvm/lib/IR/Pass.cpp
index 2c5ef7193b463..9419c8d0af9c5 100644
--- a/llvm/lib/IR/Pass.cpp
+++ b/llvm/lib/IR/Pass.cpp
@@ -40,9 +40,7 @@ using namespace llvm;
//
// Force out-of-line virtual method.
-Pass::~Pass() {
- delete Resolver;
-}
+Pass::~Pass() { delete Resolver; }
// Force out-of-line virtual method.
ModulePass::~ModulePass() = default;
@@ -62,8 +60,12 @@ static std::string getDescription(const Module &M) {
bool ModulePass::skipModule(const Module &M) const {
const OptPassGate &Gate = M.getContext().getOptPassGate();
- return Gate.isEnabled() &&
- !Gate.shouldRunPass(this->getPassName(), getDescription(M));
+
+ StringRef PassName = this->getPassArgument();
+ if (PassName.empty())
+ PassName = this->getPassName();
+
+ return Gate.isEnabled() && !Gate.shouldRunPass(PassName, getDescription(M));
}
bool Pass::mustPreserveAnalysisID(char &AID) const {
@@ -72,20 +74,30 @@ bool Pass::mustPreserveAnalysisID(char &AID) const {
// dumpPassStructure - Implement the -debug-pass=Structure option
void Pass::dumpPassStructure(unsigned Offset) {
- dbgs().indent(Offset*2) << getPassName() << "\n";
+ dbgs().indent(Offset * 2) << getPassName() << "\n";
}
/// getPassName - Return a nice clean name for a pass. This usually
/// implemented in terms of the name that is registered by one of the
/// Registration templates, but can be overloaded directly.
StringRef Pass::getPassName() const {
- AnalysisID AID = getPassID();
+ AnalysisID AID = getPassID();
const PassInfo *PI = PassRegistry::getPassRegistry()->getPassInfo(AID);
if (PI)
return PI->getPassName();
return "Unnamed pass: implement Pass::getPassName()";
}
+/// getPassArgument - Return a nice clean name for a pass
+/// corresponding to that used to enable the pass in opt
+StringRef Pass::getPassArgument() const {
+ AnalysisID AID = getPassID();
+ const PassInfo *PI = PassRegistry::getPassRegistry()->getPassInfo(AID);
+ if (PI)
+ return PI->getPassArgument();
+ return "";
+}
+
void Pass::preparePassManager(PMStack &) {
// By default, don't do anything.
}
@@ -107,13 +119,9 @@ void Pass::verifyAnalysis() const {
// By default, don't do anything.
}
-ImmutablePass *Pass::getAsImmutablePass() {
- return nullptr;
-}
+ImmutablePass *Pass::getAsImmutablePass() { return nullptr; }
-PMDataManager *Pass::getAsPMDataManager() {
- return nullptr;
-}
+PMDataManager *Pass::getAsPMDataManager() { return nullptr; }
void Pass::setResolver(AnalysisResolver *AR) {
assert(!Resolver && "Resolver is already set");
@@ -129,9 +137,7 @@ void Pass::print(raw_ostream &OS, const Module *) const {
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
// dump - call print(cerr);
-LLVM_DUMP_METHOD void Pass::dump() const {
- print(dbgs(), nullptr);
-}
+LLVM_DUMP_METHOD void Pass::dump() const { print(dbgs(), nullptr); }
#endif
#ifdef EXPENSIVE_CHECKS
@@ -173,8 +179,12 @@ static std::string getDescription(const Function &F) {
bool FunctionPass::skipFunction(const Function &F) const {
OptPassGate &Gate = F.getContext().getOptPassGate();
- if (Gate.isEnabled() &&
- !Gate.shouldRunPass(this->getPassName(), getDescription(F)))
+
+ StringRef PassName = this->getPassArgument();
+ if (PassName.empty())
+ PassName = this->getPassName();
+
+ if (Gate.isEnabled() && !Gate.shouldRunPass(PassName, getDescription(F)))
return true;
if (F.hasOptNone()) {
diff --git a/llvm/lib/Passes/StandardInstrumentations.cpp
b/llvm/lib/Passes/StandardInstrumentations.cpp
index 0623e66772047..e2de2e734881a 100644
--- a/llvm/lib/Passes/StandardInstrumentations.cpp
+++ b/llvm/lib/Passes/StandardInstrumentations.cpp
@@ -105,18 +105,19 @@ static cl::opt<std::string> PrintOnCrashPath(
cl::desc("Print the last form of the IR before crash to a file"),
cl::Hidden);
-static cl::opt<bool> PrintOnCrash(
- "print-on-crash",
- cl::desc("Print the last form of the IR before crash (use
-print-on-crash-path to dump to a file)"),
- cl::Hidden);
+static cl::opt<bool>
+ PrintOnCrash("print-on-crash",
+ cl::desc("Print the last form of the IR before crash (use "
+ "-print-on-crash-path to dump to a file)"),
+ cl::Hidden);
static cl::opt<std::string> OptBisectPrintIRPath(
"opt-bisect-print-ir-path",
cl::desc("Print IR to path when opt-bisect-limit is reached"), cl::Hidden);
-static cl::opt<bool> PrintPassNumbers(
- "print-pass-numbers", cl::init(false), cl::Hidden,
- cl::desc("Print pass names and their ordinals"));
+static cl::opt<bool>
+ PrintPassNumbers("print-pass-numbers", cl::init(false), cl::Hidden,
+ cl::desc("Print pass names and their ordinals"));
static cl::opt<unsigned> PrintBeforePassNumber(
"print-before-pass-number", cl::init(0), cl::Hidden,
@@ -863,8 +864,8 @@ void PrintIRInstrumentation::printBeforePass(StringRef
PassID, Any IR) {
++CurrentPassNumber;
if (shouldPrintPassNumbers())
- dbgs() << " Running pass " << CurrentPassNumber << " " << PassID
- << " on " << getIRName(IR) << "\n";
+ dbgs() << " Running pass " << CurrentPassNumber << " " << PassID << " on "
+ << getIRName(IR) << "\n";
if (shouldPrintAfterCurrentPassNumber())
pushPassRunDescriptor(PassID, IR, CurrentPassNumber);
@@ -1078,9 +1079,13 @@ void OptPassGateInstrumentation::registerCallbacks(
if (!PassGate.isEnabled())
return;
- PIC.registerShouldRunOptionalPassCallback([this](StringRef PassName, Any IR)
{
- return this->shouldRun(PassName, IR);
- });
+ PIC.registerShouldRunOptionalPassCallback(
+ [this, &PIC](StringRef ClassName, Any IR) {
+ StringRef PassName = PIC.getPassNameForClassName(ClassName);
+ if (PassName.empty())
+ return this->shouldRun(ClassName, IR);
+ return this->shouldRun(PassName, IR);
+ });
}
raw_ostream &PrintPassInstrumentation::print() {
@@ -1109,29 +1114,29 @@ void PrintPassInstrumentation::registerCallbacks(
print() << "Skipping pass: " << PassID << " on " << getIRName(IR) << "\n";
});
- PIC.registerBeforeNonSkippedPassCallback([this, SpecialPasses](
- StringRef PassID, Any IR) {
- if (isSpecialPass(PassID, SpecialPasses))
- return;
+ PIC.registerBeforeNonSkippedPassCallback(
+ [this, SpecialPasses](StringRef PassID, Any IR) {
+ if (isSpecialPass(PassID, SpecialPasses))
+ return;
- auto &OS = print();
- OS << "Running pass: " << PassID << " on " << getIRName(IR);
- if (const auto *F = unwrapIR<Function>(IR)) {
- unsigned Count = F->getInstructionCount();
- OS << " (" << Count << " instruction";
- if (Count != 1)
- OS << 's';
- OS << ')';
- } else if (const auto *C = unwrapIR<LazyCallGraph::SCC>(IR)) {
- int Count = C->size();
- OS << " (" << Count << " node";
- if (Count != 1)
- OS << 's';
- OS << ')';
- }
- OS << "\n";
- Indent += 2;
- });
+ auto &OS = print();
+ OS << "Running pass: " << PassID << " on " << getIRName(IR);
+ if (const auto *F = unwrapIR<Function>(IR)) {
+ unsigned Count = F->getInstructionCount();
+ OS << " (" << Count << " instruction";
+ if (Count != 1)
+ OS << 's';
+ OS << ')';
+ } else if (const auto *C = unwrapIR<LazyCallGraph::SCC>(IR)) {
+ int Count = C->size();
+ OS << " (" << Count << " node";
+ if (Count != 1)
+ OS << 's';
+ OS << ')';
+ }
+ OS << "\n";
+ Indent += 2;
+ });
PIC.registerAfterPassCallback(
[this, SpecialPasses](StringRef PassID, Any IR,
const PreservedAnalyses &) {
@@ -1450,75 +1455,72 @@ void
PreservedCFGCheckerInstrumentation::registerCallbacks(
void VerifyInstrumentation::registerCallbacks(PassInstrumentationCallbacks
&PIC,
ModuleAnalysisManager *MAM) {
- PIC.registerAfterPassCallback(
- [this, MAM](StringRef P, Any IR, const PreservedAnalyses &PassPA) {
- if (isIgnored(P) || P == "VerifierPass")
- return;
- const auto *F = unwrapIR<Function>(IR);
- if (!F) {
- if (const auto *L = unwrapIR<Loop>(IR))
- F = L->getHeader()->getParent();
- }
+ PIC.registerAfterPassCallback([this, MAM](StringRef P, Any IR,
+ const PreservedAnalyses &PassPA) {
+ if (isIgnored(P) || P == "VerifierPass")
+ return;
+ const auto *F = unwrapIR<Function>(IR);
+ if (!F) {
+ if (const auto *L = unwrapIR<Loop>(IR))
+ F = L->getHeader()->getParent();
+ }
+
+ if (F) {
+ if (DebugLogging)
+ dbgs() << "Verifying function " << F->getName() << "\n";
+
+ if (verifyFunction(*F, &errs()))
+ report_fatal_error(formatv("Broken function found after pass "
+ "\"{0}\", compilation aborted!",
+ P));
+ } else {
+ const auto *M = unwrapIR<Module>(IR);
+ if (!M) {
+ if (const auto *C = unwrapIR<LazyCallGraph::SCC>(IR))
+ M = C->begin()->getFunction().getParent();
+ }
+
+ if (M) {
+ if (DebugLogging)
+ dbgs() << "Verifying module " << M->getName() << "\n";
- if (F) {
- if (DebugLogging)
- dbgs() << "Verifying function " << F->getName() << "\n";
+ if (verifyModule(*M, &errs()))
+ report_fatal_error(formatv("Broken module found after pass "
+ "\"{0}\", compilation aborted!",
+ P));
+ }
- if (verifyFunction(*F, &errs()))
- report_fatal_error(formatv("Broken function found after pass "
- "\"{0}\", compilation aborted!",
- P));
+ if (auto *MF = unwrapIR<MachineFunction>(IR)) {
+ if (DebugLogging)
+ dbgs() << "Verifying machine function " << MF->getName() << '\n';
+ std::string Banner = formatv("Broken machine function found after pass
"
+ "\"{0}\", compilation aborted!",
+ P);
+ if (MAM) {
+ Module &M = const_cast<Module &>(*MF->getFunction().getParent());
+ auto &MFAM =
+ MAM->getResult<MachineFunctionAnalysisManagerModuleProxy>(M)
+ .getManager();
+ MachineVerifierPass Verifier(Banner);
+ Verifier.run(const_cast<MachineFunction &>(*MF), MFAM);
} else {
- const auto *M = unwrapIR<Module>(IR);
- if (!M) {
- if (const auto *C = unwrapIR<LazyCallGraph::SCC>(IR))
- M = C->begin()->getFunction().getParent();
- }
-
- if (M) {
- if (DebugLogging)
- dbgs() << "Verifying module " << M->getName() << "\n";
-
- if (verifyModule(*M, &errs()))
- report_fatal_error(formatv("Broken module found after pass "
- "\"{0}\", compilation aborted!",
- P));
- }
-
- if (auto *MF = unwrapIR<MachineFunction>(IR)) {
- if (DebugLogging)
- dbgs() << "Verifying machine function " << MF->getName() << '\n';
- std::string Banner =
- formatv("Broken machine function found after pass "
- "\"{0}\", compilation aborted!",
- P);
- if (MAM) {
- Module &M = const_cast<Module &>(*MF->getFunction().getParent());
- auto &MFAM =
- MAM->getResult<MachineFunctionAnalysisManagerModuleProxy>(M)
- .getManager();
- MachineVerifierPass Verifier(Banner);
- Verifier.run(const_cast<MachineFunction &>(*MF), MFAM);
- } else {
- verifyMachineFunction(Banner, *MF);
- }
- }
+ verifyMachineFunction(Banner, *MF);
}
- });
+ }
+ }
+ });
}
InLineChangePrinter::~InLineChangePrinter() = default;
-void InLineChangePrinter::generateIRRepresentation(Any IR,
- StringRef PassID,
+void InLineChangePrinter::generateIRRepresentation(Any IR, StringRef PassID,
IRDataT<EmptyData> &D) {
IRComparer<EmptyData>::analyzeIR(IR, D);
}
void InLineChangePrinter::handleAfter(StringRef PassID, std::string &Name,
const IRDataT<EmptyData> &Before,
- const IRDataT<EmptyData> &After,
- Any IR) {
+ const IRDataT<EmptyData> &After, Any IR)
{
SmallString<20> Banner =
formatv("*** IR Dump After {0} on {1} ***\n", PassID, Name);
Out << Banner;
@@ -2420,7 +2422,7 @@ DotCfgChangeReporter::~DotCfgChangeReporter() {
void DotCfgChangeReporter::registerCallbacks(
PassInstrumentationCallbacks &PIC) {
if (PrintChanged == ChangePrinter::DotCfgVerbose ||
- PrintChanged == ChangePrinter::DotCfgQuiet) {
+ PrintChanged == ChangePrinter::DotCfgQuiet) {
SmallString<128> OutputDir;
sys::fs::expand_tilde(DotCfgDir, OutputDir);
sys::fs::make_absolute(OutputDir);
diff --git a/llvm/test/Other/opt-disable.ll b/llvm/test/Other/opt-disable.ll
index 63d59c5792d3f..4506042215cbf 100644
--- a/llvm/test/Other/opt-disable.ll
+++ b/llvm/test/Other/opt-disable.ll
@@ -4,33 +4,33 @@
; RUN: opt -disable-output -disable-verify \
; RUN: -opt-disable-enable-verbosity \
-; RUN: -passes=inferattrs -opt-disable=inferfunctionattrspass %s 2>&1 \
+; RUN: -passes=inferattrs -opt-disable=inferattrs %s 2>&1 \
; RUN: | FileCheck %s --check-prefix=CHECK-MODULE-PASS
-; CHECK-MODULE-PASS: DISABLE: NOT running pass InferFunctionAttrsPass on
[module]
+; CHECK-MODULE-PASS: OptDisable: NOT running pass inferattrs on [module]
; RUN: opt -disable-output -disable-verify \
; RUN: -opt-disable-enable-verbosity \
-; RUN: -passes=sroa -opt-disable=sroapass %s 2>&1 \
+; RUN: -passes=sroa -opt-disable=sroa %s 2>&1 \
; RUN: | FileCheck %s --check-prefix=CHECK-FUNCTION-PASS
-; CHECK-FUNCTION-PASS: DISABLE: NOT running pass SROAPass on f1
-; CHECK-FUNCTION-PASS: DISABLE: NOT running pass SROAPass on f2
-; CHECK-FUNCTION-PASS: DISABLE: NOT running pass SROAPass on f3
-; CHECK-FUNCTION-PASS: DISABLE: NOT running pass SROAPass on f4
+; CHECK-FUNCTION-PASS: OptDisable: NOT running pass sroa on f1
+; CHECK-FUNCTION-PASS: OptDisable: NOT running pass sroa on f2
+; CHECK-FUNCTION-PASS: OptDisable: NOT running pass sroa on f3
+; CHECK-FUNCTION-PASS: OptDisable: NOT running pass sroa on f4
; RUN: opt -disable-output -disable-verify \
-; RUN: -opt-disable=inferfunctionattrspass,PostOrderFunctionAttrsPass \
+; RUN: -opt-disable=inferattrs,function-attrs \
; RUN: -opt-disable-enable-verbosity \
; RUN: -passes='inferattrs,cgscc(function-attrs,function(early-cse))' %s
2>&1 \
; RUN: | FileCheck %s --check-prefix=CHECK-MULTI-PASS
-; CHECK-MULTI-PASS: DISABLE: NOT running pass InferFunctionAttrsPass on
[module]
-; CHECK-MULTI-PASS: DISABLE: NOT running pass PostOrderFunctionAttrsPass on
(f1)
-; CHECK-MULTI-PASS: DISABLE: running pass EarlyCSEPass on f1
-; CHECK-MULTI-PASS: DISABLE: NOT running pass PostOrderFunctionAttrsPass on
(f2)
-; CHECK-MULTI-PASS: DISABLE: running pass EarlyCSEPass on f2
-; CHECK-MULTI-PASS: DISABLE: NOT running pass PostOrderFunctionAttrsPass on
(f3)
-; CHECK-MULTI-PASS: DISABLE: running pass EarlyCSEPass on f3
-; CHECK-MULTI-PASS: DISABLE: NOT running pass PostOrderFunctionAttrsPass on
(f4)
-; CHECK-MULTI-PASS: DISABLE: running pass EarlyCSEPass on f4
+; CHECK-MULTI-PASS: OptDisable: NOT running pass inferattrs on [module]
+; CHECK-MULTI-PASS: OptDisable: NOT running pass function-attrs on (f1)
+; CHECK-MULTI-PASS: OptDisable: running pass early-cse on f1
+; CHECK-MULTI-PASS: OptDisable: NOT running pass function-attrs on (f2)
+; CHECK-MULTI-PASS: OptDisable: running pass early-cse on f2
+; CHECK-MULTI-PASS: OptDisable: NOT running pass function-attrs on (f3)
+; CHECK-MULTI-PASS: OptDisable: running pass early-cse on f3
+; CHECK-MULTI-PASS: OptDisable: NOT running pass function-attrs on (f4)
+; CHECK-MULTI-PASS: OptDisable: running pass early-cse on f4
declare i32 @g()
>From 4810d329119d61719247c8d52fc9a773daa72a7d Mon Sep 17 00:00:00 2001
From: Cristian Assaiante <cristianassaia...@outlook.com>
Date: Thu, 10 Jul 2025 09:45:31 +0200
Subject: [PATCH 11/11] Update failing opt-bisect test
---
.../test/Other/opt-bisect-new-pass-manager.ll | 76 +++++++++----------
1 file changed, 38 insertions(+), 38 deletions(-)
diff --git a/llvm/test/Other/opt-bisect-new-pass-manager.ll
b/llvm/test/Other/opt-bisect-new-pass-manager.ll
index 01dad705ec362..8f8078d4d8409 100644
--- a/llvm/test/Other/opt-bisect-new-pass-manager.ll
+++ b/llvm/test/Other/opt-bisect-new-pass-manager.ll
@@ -11,84 +11,84 @@
; RUN: opt -disable-output -disable-verify \
; RUN: -passes=inferattrs -opt-bisect-limit=-1 %s 2>&1 \
; RUN: | FileCheck %s --check-prefix=CHECK-MODULE-PASS
-; CHECK-MODULE-PASS: BISECT: running pass (1) InferFunctionAttrsPass on
[module]
+; CHECK-MODULE-PASS: BISECT: running pass (1) inferattrs on [module]
; RUN: opt -disable-output -disable-verify \
; RUN: -passes=inferattrs -opt-bisect-limit=0 %s 2>&1 \
; RUN: | FileCheck %s --check-prefix=CHECK-LIMIT-MODULE-PASS
-; CHECK-LIMIT-MODULE-PASS: BISECT: NOT running pass (1) InferFunctionAttrsPass
on [module]
+; CHECK-LIMIT-MODULE-PASS: BISECT: NOT running pass (1) inferattrs on [module]
; RUN: opt -disable-output -debug-pass-manager \
; RUN: -passes=inferattrs -opt-bisect-limit=-1 %s 2>&1 \
; RUN: | FileCheck %s --check-prefix=CHECK-REQUIRED-PASS
-; CHECK-REQUIRED-PASS: BISECT: running pass (1) InferFunctionAttrsPass on
[module]
+; CHECK-REQUIRED-PASS: BISECT: running pass (1) inferattrs on [module]
; CHECK-REQUIRED-PASS-NOT: BISECT: {{.*}}VerifierPass
; CHECK-REQUIRED-PASS: Running pass: VerifierPass
; RUN: opt -disable-output -debug-pass-manager \
; RUN: -passes=inferattrs -opt-bisect-limit=0 %s 2>&1 \
; RUN: | FileCheck %s --check-prefix=CHECK-LIMIT-REQUIRED-PASS
-; CHECK-LIMIT-REQUIRED-PASS: BISECT: NOT running pass (1)
InferFunctionAttrsPass on [module]
+; CHECK-LIMIT-REQUIRED-PASS: BISECT: NOT running pass (1) inferattrs on
[module]
; CHECK-LIMIT-REQUIRED-PASS-NOT: BISECT: {{.*}}VerifierPass
; CHECK-LIMIT-REQUIRED-PASS: Running pass: VerifierPass
; RUN: opt -disable-output -disable-verify \
; RUN: -passes=early-cse -opt-bisect-limit=-1 %s 2>&1 \
; RUN: | FileCheck %s --check-prefix=CHECK-FUNCTION-PASS
-; CHECK-FUNCTION-PASS: BISECT: running pass (1) EarlyCSEPass on f1
-; CHECK-FUNCTION-PASS: BISECT: running pass (2) EarlyCSEPass on f2
-; CHECK-FUNCTION-PASS: BISECT: running pass (3) EarlyCSEPass on f3
-; CHECK-FUNCTION-PASS: BISECT: running pass (4) EarlyCSEPass on f4
+; CHECK-FUNCTION-PASS: BISECT: running pass (1) early-cse on f1
+; CHECK-FUNCTION-PASS: BISECT: running pass (2) early-cse on f2
+; CHECK-FUNCTION-PASS: BISECT: running pass (3) early-cse on f3
+; CHECK-FUNCTION-PASS: BISECT: running pass (4) early-cse on f4
; RUN: opt -disable-output -disable-verify \
; RUN: -passes=early-cse -opt-bisect-limit=2 %s 2>&1 \
; RUN: | FileCheck %s --check-prefix=CHECK-LIMIT-FUNCTION-PASS
-; CHECK-LIMIT-FUNCTION-PASS: BISECT: running pass (1) EarlyCSEPass on f1
-; CHECK-LIMIT-FUNCTION-PASS: BISECT: running pass (2) EarlyCSEPass on f2
-; CHECK-LIMIT-FUNCTION-PASS: BISECT: NOT running pass (3) EarlyCSEPass on f3
-; CHECK-LIMIT-FUNCTION-PASS: BISECT: NOT running pass (4) EarlyCSEPass on f4
+; CHECK-LIMIT-FUNCTION-PASS: BISECT: running pass (1) early-cse on f1
+; CHECK-LIMIT-FUNCTION-PASS: BISECT: running pass (2) early-cse on f2
+; CHECK-LIMIT-FUNCTION-PASS: BISECT: NOT running pass (3) early-cse on f3
+; CHECK-LIMIT-FUNCTION-PASS: BISECT: NOT running pass (4) early-cse on f4
; RUN: opt -disable-output -disable-verify \
; RUN: -passes=function-attrs -opt-bisect-limit=-1 %s 2>&1 \
; RUN: | FileCheck %s --check-prefix=CHECK-CGSCC-PASS
-; CHECK-CGSCC-PASS: BISECT: running pass (1) PostOrderFunctionAttrsPass on (f1)
-; CHECK-CGSCC-PASS: BISECT: running pass (2) PostOrderFunctionAttrsPass on (f2)
-; CHECK-CGSCC-PASS: BISECT: running pass (3) PostOrderFunctionAttrsPass on (f3)
-; CHECK-CGSCC-PASS: BISECT: running pass (4) PostOrderFunctionAttrsPass on (f4)
+; CHECK-CGSCC-PASS: BISECT: running pass (1) function-attrs on (f1)
+; CHECK-CGSCC-PASS: BISECT: running pass (2) function-attrs on (f2)
+; CHECK-CGSCC-PASS: BISECT: running pass (3) function-attrs on (f3)
+; CHECK-CGSCC-PASS: BISECT: running pass (4) function-attrs on (f4)
; RUN: opt -disable-output -disable-verify \
; RUN: -passes=function-attrs -opt-bisect-limit=3 %s 2>&1 \
; RUN: | FileCheck %s --check-prefix=CHECK-LIMIT-CGSCC-PASS
-; CHECK-LIMIT-CGSCC-PASS: BISECT: running pass (1) PostOrderFunctionAttrsPass
on (f1)
-; CHECK-LIMIT-CGSCC-PASS: BISECT: running pass (2) PostOrderFunctionAttrsPass
on (f2)
-; CHECK-LIMIT-CGSCC-PASS: BISECT: running pass (3) PostOrderFunctionAttrsPass
on (f3)
-; CHECK-LIMIT-CGSCC-PASS: BISECT: NOT running pass (4)
PostOrderFunctionAttrsPass on (f4)
+; CHECK-LIMIT-CGSCC-PASS: BISECT: running pass (1) function-attrs on (f1)
+; CHECK-LIMIT-CGSCC-PASS: BISECT: running pass (2) function-attrs on (f2)
+; CHECK-LIMIT-CGSCC-PASS: BISECT: running pass (3) function-attrs on (f3)
+; CHECK-LIMIT-CGSCC-PASS: BISECT: NOT running pass (4) function-attrs on (f4)
; RUN: opt -disable-output -disable-verify -opt-bisect-limit=-1 \
; RUN: -passes='inferattrs,cgscc(function-attrs,function(early-cse))' %s
2>&1 \
; RUN: | FileCheck %s --check-prefix=CHECK-MULTI-PASS
-; CHECK-MULTI-PASS: BISECT: running pass (1) InferFunctionAttrsPass on [module]
-; CHECK-MULTI-PASS: BISECT: running pass (2) PostOrderFunctionAttrsPass on (f1)
-; CHECK-MULTI-PASS: BISECT: running pass (3) EarlyCSEPass on f1
-; CHECK-MULTI-PASS: BISECT: running pass (4) PostOrderFunctionAttrsPass on (f2)
-; CHECK-MULTI-PASS: BISECT: running pass (5) EarlyCSEPass on f2
-; CHECK-MULTI-PASS: BISECT: running pass (6) PostOrderFunctionAttrsPass on (f3)
-; CHECK-MULTI-PASS: BISECT: running pass (7) EarlyCSEPass on f3
-; CHECK-MULTI-PASS: BISECT: running pass (8) PostOrderFunctionAttrsPass on (f4)
-; CHECK-MULTI-PASS: BISECT: running pass (9) EarlyCSEPass on f4
+; CHECK-MULTI-PASS: BISECT: running pass (1) inferattrs on [module]
+; CHECK-MULTI-PASS: BISECT: running pass (2) function-attrs on (f1)
+; CHECK-MULTI-PASS: BISECT: running pass (3) early-cse on f1
+; CHECK-MULTI-PASS: BISECT: running pass (4) function-attrs on (f2)
+; CHECK-MULTI-PASS: BISECT: running pass (5) early-cse on f2
+; CHECK-MULTI-PASS: BISECT: running pass (6) function-attrs on (f3)
+; CHECK-MULTI-PASS: BISECT: running pass (7) early-cse on f3
+; CHECK-MULTI-PASS: BISECT: running pass (8) function-attrs on (f4)
+; CHECK-MULTI-PASS: BISECT: running pass (9) early-cse on f4
; RUN: opt -disable-output -disable-verify -opt-bisect-limit=7 \
; RUN: -passes='inferattrs,cgscc(function-attrs,function(early-cse))' %s
2>&1 \
; RUN: | FileCheck %s --check-prefix=CHECK-LIMIT-MULTI-PASS
-; CHECK-LIMIT-MULTI-PASS: BISECT: running pass (1) InferFunctionAttrsPass on
[module]
-; CHECK-LIMIT-MULTI-PASS: BISECT: running pass (2) PostOrderFunctionAttrsPass
on (f1)
-; CHECK-LIMIT-MULTI-PASS: BISECT: running pass (3) EarlyCSEPass on f1
-; CHECK-LIMIT-MULTI-PASS: BISECT: running pass (4) PostOrderFunctionAttrsPass
on (f2)
-; CHECK-LIMIT-MULTI-PASS: BISECT: running pass (5) EarlyCSEPass on f2
-; CHECK-LIMIT-MULTI-PASS: BISECT: running pass (6) PostOrderFunctionAttrsPass
on (f3)
-; CHECK-LIMIT-MULTI-PASS: BISECT: running pass (7) EarlyCSEPass on f3
-; CHECK-LIMIT-MULTI-PASS: BISECT: NOT running pass (8)
PostOrderFunctionAttrsPass on (f4)
-; CHECK-LIMIT-MULTI-PASS: BISECT: NOT running pass (9) EarlyCSEPass on f4
+; CHECK-LIMIT-MULTI-PASS: BISECT: running pass (1) inferattrs on [module]
+; CHECK-LIMIT-MULTI-PASS: BISECT: running pass (2) function-attrs on (f1)
+; CHECK-LIMIT-MULTI-PASS: BISECT: running pass (3) early-cse on f1
+; CHECK-LIMIT-MULTI-PASS: BISECT: running pass (4) function-attrs on (f2)
+; CHECK-LIMIT-MULTI-PASS: BISECT: running pass (5) early-cse on f2
+; CHECK-LIMIT-MULTI-PASS: BISECT: running pass (6) function-attrs on (f3)
+; CHECK-LIMIT-MULTI-PASS: BISECT: running pass (7) early-cse on f3
+; CHECK-LIMIT-MULTI-PASS: BISECT: NOT running pass (8) function-attrs on (f4)
+; CHECK-LIMIT-MULTI-PASS: BISECT: NOT running pass (9) early-cse on f4
; Make sure we don't skip writing the output to stdout.
; RUN: opt %s -opt-bisect-limit=0 -passes=early-cse | opt -S | FileCheck %s
-check-prefix=CHECK-OUTPUT
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
