// 6. When a pass is run on an IR that is not interesting (based on options).
// 7. When a pass is ignored (pass manager or adapter pass).
// 8. To compare two IR representations (of type \p T).
-template <typename IRUnitT> class ChangePrinter {
+template <typename IRUnitT> class ChangeReporter {
protected:
- ChangePrinter() {}
+ ChangeReporter() {}
public:
- virtual ~ChangePrinter();
+ virtual ~ChangeReporter();
// Determine if this pass/IR is interesting and if so, save the IR
// otherwise it is left on the stack without data.
void handleInvalidatedPass(StringRef PassID);
protected:
+ // Register required callbacks.
+ void registerRequiredCallbacks(PassInstrumentationCallbacks &PIC);
+
+ // Return true when this is a defined function for which printing
+ // of changes is desired.
+ bool isInterestingFunction(const Function &F);
+
+ // Return true when this is a pass for which printing of changes is desired.
+ bool isInterestingPass(StringRef PassID);
+
+ // Return true when this is a pass on IR for which printing
+ // of changes is desired.
+ bool isInteresting(Any IR, StringRef PassID);
+
// Called on the first IR processed.
virtual void handleInitialIR(Any IR) = 0;
// Called before and after a pass to get the representation of the IR.
bool InitialIR = true;
};
+// An abstract template base class that handles printing banners and
+// reporting when things have not changed or are filtered out.
+template <typename IRUnitT>
+class TextChangeReporter : public ChangeReporter<IRUnitT> {
+protected:
+ TextChangeReporter();
+
+ // Print a module dump of the first IR that is changed.
+ void handleInitialIR(Any IR) override;
+ // Report that the IR was omitted because it did not change.
+ void omitAfter(StringRef PassID, std::string &Name) override;
+ // Report that the pass was invalidated.
+ void handleInvalidated(StringRef PassID) override;
+ // Report that the IR was filtered out.
+ void handleFiltered(StringRef PassID, std::string &Name) override;
+ // Report that the pass was ignored.
+ void handleIgnored(StringRef PassID, std::string &Name) override;
+ // Make substitutions in \p S suitable for reporting changes
+ // after the pass and then print it.
+
+ raw_ostream &Out;
+};
+
// A change printer based on the string representation of the IR as created
// by unwrapAndPrint. The string representation is stored in a std::string
// to preserve it as the IR changes in each pass. Note that the banner is
// included in this representation but it is massaged before reporting.
-class IRChangePrinter : public ChangePrinter<std::string> {
+class IRChangedPrinter : public TextChangeReporter<std::string> {
public:
- IRChangePrinter();
- ~IRChangePrinter() override;
+ IRChangedPrinter() {}
+ ~IRChangedPrinter() override;
void registerCallbacks(PassInstrumentationCallbacks &PIC);
protected:
- // Called on the first IR processed.
- void handleInitialIR(Any IR) override;
// Called before and after a pass to get the representation of the IR.
void generateIRRepresentation(Any IR, StringRef PassID,
std::string &Output) override;
- // Called when the pass is not iteresting.
- void omitAfter(StringRef PassID, std::string &Name) override;
// Called when an interesting IR has changed.
void handleAfter(StringRef PassID, std::string &Name,
const std::string &Before, const std::string &After,
Any) override;
- // Called when an interesting pass is invalidated.
- void handleInvalidated(StringRef PassID) override;
- // Called when the IR or pass is not interesting.
- void handleFiltered(StringRef PassID, std::string &Name) override;
- // Called when an ignored pass is encountered.
- void handleIgnored(StringRef PassID, std::string &Name) override;
// Called to compare the before and after representations of the IR.
bool same(const std::string &Before, const std::string &After) override;
-
- raw_ostream &Out;
};
class VerifyInstrumentation {
OptNoneInstrumentation OptNone;
OptBisectInstrumentation OptBisect;
PreservedCFGCheckerInstrumentation PreservedCFGChecker;
- IRChangePrinter PrintChangedIR;
+ IRChangedPrinter PrintChangedIR;
VerifyInstrumentation Verify;
bool VerifyEach;
TimePassesHandler &getTimePasses() { return TimePasses; }
};
+
+extern template class ChangeReporter<std::string>;
+extern template class TextChangeReporter<std::string>;
+
} // namespace llvm
#endif
{"PassManager", "PassAdaptor", "AnalysisManagerProxy"});
}
-// Return true when this is a defined function for which printing
-// of changes is desired.
-bool isInterestingFunction(const Function &F) {
+} // namespace
+
+template <typename IRUnitT>
+ChangeReporter<IRUnitT>::~ChangeReporter<IRUnitT>() {
+ assert(BeforeStack.empty() && "Problem with Change Printer stack.");
+}
+
+template <typename IRUnitT>
+bool ChangeReporter<IRUnitT>::isInterestingFunction(const Function &F) {
return llvm::isFunctionInPrintList(F.getName());
}
-// Return true when this is a pass for which printing of changes is desired.
-bool isInterestingPass(StringRef PassID) {
+template <typename IRUnitT>
+bool ChangeReporter<IRUnitT>::isInterestingPass(StringRef PassID) {
if (isIgnored(PassID))
return false;
// Return true when this is a pass on IR for which printing
// of changes is desired.
-bool isInteresting(Any IR, StringRef PassID) {
+template <typename IRUnitT>
+bool ChangeReporter<IRUnitT>::isInteresting(Any IR, StringRef PassID) {
if (!isInterestingPass(PassID))
return false;
if (any_isa<const Function *>(IR))
return true;
}
-} // namespace
-
template <typename IRUnitT>
-void ChangePrinter<IRUnitT>::saveIRBeforePass(Any IR, StringRef PassID) {
+void ChangeReporter<IRUnitT>::saveIRBeforePass(Any IR, StringRef PassID) {
// Always need to place something on the stack because invalidated passes
// are not given the IR so it cannot be determined whether the pass was for
// something that was filtered out.
}
template <typename IRUnitT>
-void ChangePrinter<IRUnitT>::handleIRAfterPass(Any IR, StringRef PassID) {
+void ChangeReporter<IRUnitT>::handleIRAfterPass(Any IR, StringRef PassID) {
assert(!BeforeStack.empty() && "Unexpected empty stack encountered.");
std::string Name;
if (auto UM = unwrapModule(IR))
Name = UM->second;
}
- if (Name.empty())
+ if (Name == "")
Name = " (module)";
if (isIgnored(PassID))
}
template <typename IRUnitT>
-void ChangePrinter<IRUnitT>::handleInvalidatedPass(StringRef PassID) {
+void ChangeReporter<IRUnitT>::handleInvalidatedPass(StringRef PassID) {
assert(!BeforeStack.empty() && "Unexpected empty stack encountered.");
// Always flag it as invalidated as we cannot determine when
BeforeStack.pop_back();
}
-template <typename IRUnitT> ChangePrinter<IRUnitT>::~ChangePrinter<IRUnitT>() {
- assert(BeforeStack.empty() && "Problem with Change Printer stack.");
-}
-
-IRChangePrinter::IRChangePrinter() : Out(dbgs()) {}
-
-IRChangePrinter::~IRChangePrinter() {}
-
-void IRChangePrinter::registerCallbacks(PassInstrumentationCallbacks &PIC) {
- if (!PrintChanged)
- return;
-
+template <typename IRUnitT>
+void ChangeReporter<IRUnitT>::registerRequiredCallbacks(
+ PassInstrumentationCallbacks &PIC) {
PIC.registerBeforeNonSkippedPassCallback(
[this](StringRef P, Any IR) { saveIRBeforePass(IR, P); });
});
}
-void IRChangePrinter::handleInitialIR(Any IR) {
+template <typename IRUnitT>
+TextChangeReporter<IRUnitT>::TextChangeReporter()
+ : ChangeReporter<IRUnitT>(), Out(dbgs()) {}
+
+template <typename IRUnitT>
+void TextChangeReporter<IRUnitT>::handleInitialIR(Any IR) {
// Always print the module.
// Unwrap and print directly to avoid filtering problems in general routines.
auto UnwrappedModule = unwrapModule(IR, /*Force=*/true);
/*ShouldPreserveUseListOrder=*/true);
}
-void IRChangePrinter::generateIRRepresentation(Any IR, StringRef PassID,
- std::string &Output) {
+template <typename IRUnitT>
+void TextChangeReporter<IRUnitT>::omitAfter(StringRef PassID,
+ std::string &Name) {
+ Out << formatv("*** IR Dump After {0}{1} omitted because no change ***\n",
+ PassID, Name);
+}
+
+template <typename IRUnitT>
+void TextChangeReporter<IRUnitT>::handleInvalidated(StringRef PassID) {
+ Out << formatv("*** IR Pass {0} invalidated ***\n", PassID);
+}
+
+template <typename IRUnitT>
+void TextChangeReporter<IRUnitT>::handleFiltered(StringRef PassID,
+ std::string &Name) {
+ SmallString<20> Banner =
+ formatv("*** IR Dump After {0}{1} filtered out ***\n", PassID, Name);
+ Out << Banner;
+}
+
+template <typename IRUnitT>
+void TextChangeReporter<IRUnitT>::handleIgnored(StringRef PassID,
+ std::string &Name) {
+ Out << formatv("*** IR Pass {0}{1} ignored ***\n", PassID, Name);
+}
+
+IRChangedPrinter::~IRChangedPrinter() {}
+
+void IRChangedPrinter::registerCallbacks(PassInstrumentationCallbacks &PIC) {
+ if (PrintChanged)
+ TextChangeReporter<std::string>::registerRequiredCallbacks(PIC);
+}
+
+void IRChangedPrinter::generateIRRepresentation(Any IR, StringRef PassID,
+ std::string &Output) {
raw_string_ostream OS(Output);
// use the after banner for all cases so it will match
SmallString<20> Banner = formatv("*** IR Dump After {0} ***", PassID);
- unwrapAndPrint(OS, IR, Banner, llvm::forcePrintModuleIR(),
+ unwrapAndPrint(OS, IR, Banner, forcePrintModuleIR(),
/*Brief=*/false, /*ShouldPreserveUseListOrder=*/true);
- OS.str();
-}
-void IRChangePrinter::omitAfter(StringRef PassID, std::string &Name) {
- Out << formatv("*** IR Dump After {0}{1} omitted because no change ***\n",
- PassID, Name);
+ OS.str();
}
-void IRChangePrinter::handleAfter(StringRef PassID, std::string &Name,
- const std::string &Before,
- const std::string &After, Any) {
+void IRChangedPrinter::handleAfter(StringRef PassID, std::string &Name,
+ const std::string &Before,
+ const std::string &After, Any) {
assert(After.find("*** IR Dump") == 0 && "Unexpected banner format.");
StringRef AfterRef = After;
StringRef Banner =
Out << After.substr(Banner.size());
}
-void IRChangePrinter::handleInvalidated(StringRef PassID) {
- Out << formatv("*** IR Pass {0} invalidated ***\n", PassID);
-}
-
-void IRChangePrinter::handleFiltered(StringRef PassID, std::string &Name) {
- SmallString<20> Banner =
- formatv("*** IR Dump After {0}{1} filtered out ***\n", PassID, Name);
- Out << Banner;
-}
-
-void IRChangePrinter::handleIgnored(StringRef PassID, std::string &Name) {
- Out << formatv("*** IR Pass {0}{1} ignored ***\n", PassID, Name);
-}
-
-bool IRChangePrinter::same(const std::string &Before,
- const std::string &After) {
- return Before == After;
+bool IRChangedPrinter::same(const std::string &S1, const std::string &S2) {
+ return S1 == S2;
}
PrintIRInstrumentation::~PrintIRInstrumentation() {
if (VerifyEach)
Verify.registerCallbacks(PIC);
}
+
+namespace llvm {
+
+template class ChangeReporter<std::string>;
+template class TextChangeReporter<std::string>;
+
+} // namespace llvm