#include "llvm/ADT/StringRef.h"
#include "llvm/Support/ManagedStatic.h"
+#include <limits>
namespace llvm {
/// optimization-related problems.
class OptBisect : public OptPassGate {
public:
- /// Default constructor, initializes the OptBisect state based on the
- /// -opt-bisect-limit command line argument.
- ///
- /// By default, bisection is disabled.
- ///
+ /// Default constructor. Initializes the state to "disabled". The bisection
+ /// 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.
- OptBisect();
+ OptBisect() = default;
virtual ~OptBisect() = default;
bool shouldRunPass(const Pass *P, StringRef IRDescription) override;
/// isEnabled() should return true before calling shouldRunPass().
- bool isEnabled() const override { return BisectEnabled; }
+ bool isEnabled() const override { return BisectLimit != Disabled; }
+
+ /// Set the new optimization limit and reset the counter. Passing
+ /// OptBisect::Disabled disables the limiting.
+ void setLimit(int Limit) {
+ BisectLimit = Limit;
+ LastBisectNum = 0;
+ }
/// Checks the bisect limit to determine if the specified pass should run.
///
/// instance, function passes should call FunctionPass::skipFunction().
bool checkPass(const StringRef PassName, const StringRef TargetDesc);
+ static const int Disabled = std::numeric_limits<int>::max();
+
private:
- bool BisectEnabled = false;
- unsigned LastBisectNum = 0;
+ int BisectLimit = Disabled;
+ int LastBisectNum = 0;
};
/// Singleton instance of the OptBisect class, so multiple pass managers don't
using namespace llvm;
static cl::opt<int> OptBisectLimit("opt-bisect-limit", cl::Hidden,
- cl::init(std::numeric_limits<int>::max()),
- cl::Optional,
+ cl::init(OptBisect::Disabled), cl::Optional,
+ cl::cb<void, int>([](int Limit) {
+ llvm::OptBisector->setLimit(Limit);
+ }),
cl::desc("Maximum optimization to perform"));
-OptBisect::OptBisect() : OptPassGate() {
- BisectEnabled = OptBisectLimit != std::numeric_limits<int>::max();
-}
-
static void printPassMessage(const StringRef &Name, int PassNum,
StringRef TargetDesc, bool Running) {
StringRef Status = Running ? "" : "NOT ";
}
bool OptBisect::shouldRunPass(const Pass *P, StringRef IRDescription) {
- assert(BisectEnabled);
+ assert(isEnabled());
return checkPass(P->getPassName(), IRDescription);
}
bool OptBisect::checkPass(const StringRef PassName,
const StringRef TargetDesc) {
- assert(BisectEnabled);
+ assert(isEnabled());
int CurBisectNum = ++LastBisectNum;
- bool ShouldRun = (OptBisectLimit == -1 || CurBisectNum <= OptBisectLimit);
+ bool ShouldRun = (BisectLimit == -1 || CurBisectNum <= BisectLimit);
printPassMessage(PassName, CurBisectNum, TargetDesc, ShouldRun);
return ShouldRun;
}
+const int OptBisect::Disabled;
+
ManagedStatic<OptBisect> llvm::OptBisector;