This is an archive of the discontinued LLVM Phabricator instance.

Differential D36972

[ORE] Remove Old Optimization Remark API
ClosedPublic

Authored by lenary on Aug 21 2017, 10:01 AM.

Details

Reviewers
anemet
Commits
rG6f9a9b5769b7: [ORE] Remove Old Optimization Remark API
rL311380: [ORE] Remove Old Optimization Remark API
Summary

https://bugs.llvm.org/show_bug.cgi?id=33789

Diff Detail

Repository
rL LLVM

Event Timeline

lenary created this revision.Aug 21 2017, 10:01 AM
anemet accepted this revision.Aug 21 2017, 11:43 AM

Yay, LGTM!

This revision is now accepted and ready to land.Aug 21 2017, 11:43 AM
Closed by commit rL311380: [ORE] Remove Old Optimization Remark API (authored by lenary). · Explain WhyAug 21 2017, 1:31 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
llvm/
trunk/
include/
llvm/
Analysis/
3 lines
IR/
93 lines
lib/
IR/
47 lines

Diff 112051

llvm/trunk/include/llvm/Analysis/OptimizationDiagnosticInfo.h

Show First 20 Lines • Show All 63 Lines • ▼ Show 20 Linespublic:
} }
/// Handle invalidation events in the new pass manager. /// Handle invalidation events in the new pass manager.
bool invalidate(Function &F, const PreservedAnalyses &PA, bool invalidate(Function &F, const PreservedAnalyses &PA,
FunctionAnalysisManager::Invalidator &Inv); FunctionAnalysisManager::Invalidator &Inv);
/// \brief Output the remark via the diagnostic handler and to the /// \brief Output the remark via the diagnostic handler and to the
/// optimization record file. /// optimization record file.
///
/// This is the new interface that should be now used rather than the legacy
/// emit* APIs.
void emit(DiagnosticInfoOptimizationBase &OptDiag); void emit(DiagnosticInfoOptimizationBase &OptDiag);
/// \brief Whether we allow for extra compile-time budget to perform more /// \brief Whether we allow for extra compile-time budget to perform more
/// analysis to produce fewer false positives. /// analysis to produce fewer false positives.
/// ///
/// This is useful when reporting missed optimizations. In this case we can /// This is useful when reporting missed optimizations. In this case we can
/// use the extra analysis (1) to filter trivial false positives or (2) to /// use the extra analysis (1) to filter trivial false positives or (2) to
/// provide more context so that non-trivial false positives can be quickly /// provide more context so that non-trivial false positives can be quickly
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

llvm/trunk/include/llvm/IR/DiagnosticInfo.h

Show First 20 Lines • Show All 621 Lines • ▼ Show 20 Linesprivate:
/// diagnostic. If line table information is available, the diagnostic /// diagnostic. If line table information is available, the diagnostic
/// will include the source code location. \p Msg is the message to show. /// will include the source code location. \p Msg is the message to show.
/// Note that this class does not copy this message, so this reference /// Note that this class does not copy this message, so this reference
/// must be valid for the whole life time of the diagnostic. /// must be valid for the whole life time of the diagnostic.
OptimizationRemark(const char *PassName, const Function &Fn, OptimizationRemark(const char *PassName, const Function &Fn,
const DiagnosticLocation &Loc, const Twine &Msg) const DiagnosticLocation &Loc, const Twine &Msg)
: DiagnosticInfoIROptimization(DK_OptimizationRemark, DS_Remark, PassName, : DiagnosticInfoIROptimization(DK_OptimizationRemark, DS_Remark, PassName,
Fn, Loc, Msg) {} Fn, Loc, Msg) {}
friend void emitOptimizationRemark(LLVMContext &Ctx, const char *PassName,
const Function &Fn,
const DiagnosticLocation &Loc,
const Twine &Msg);
}; };
/// Diagnostic information for missed-optimization remarks. /// Diagnostic information for missed-optimization remarks.
class OptimizationRemarkMissed : public DiagnosticInfoIROptimization { class OptimizationRemarkMissed : public DiagnosticInfoIROptimization {
public: public:
/// \p PassName is the name of the pass emitting this diagnostic. If this name /// \p PassName is the name of the pass emitting this diagnostic. If this name
/// matches the regular expression given in -Rpass-missed=, then the /// matches the regular expression given in -Rpass-missed=, then the
/// diagnostic will be emitted. \p RemarkName is a textual identifier for the /// diagnostic will be emitted. \p RemarkName is a textual identifier for the
Show All 27 Linesprivate:
/// diagnostic. If line table information is available, the diagnostic /// diagnostic. If line table information is available, the diagnostic
/// will include the source code location. \p Msg is the message to show. /// will include the source code location. \p Msg is the message to show.
/// Note that this class does not copy this message, so this reference /// Note that this class does not copy this message, so this reference
/// must be valid for the whole life time of the diagnostic. /// must be valid for the whole life time of the diagnostic.
OptimizationRemarkMissed(const char *PassName, const Function &Fn, OptimizationRemarkMissed(const char *PassName, const Function &Fn,
const DiagnosticLocation &Loc, const Twine &Msg) const DiagnosticLocation &Loc, const Twine &Msg)
: DiagnosticInfoIROptimization(DK_OptimizationRemarkMissed, DS_Remark, : DiagnosticInfoIROptimization(DK_OptimizationRemarkMissed, DS_Remark,
PassName, Fn, Loc, Msg) {} PassName, Fn, Loc, Msg) {}
friend void emitOptimizationRemarkMissed(LLVMContext &Ctx,
const char *PassName,
const Function &Fn,
const DiagnosticLocation &Loc,
const Twine &Msg);
}; };
/// Diagnostic information for optimization analysis remarks. /// Diagnostic information for optimization analysis remarks.
class OptimizationRemarkAnalysis : public DiagnosticInfoIROptimization { class OptimizationRemarkAnalysis : public DiagnosticInfoIROptimization {
public: public:
/// \p PassName is the name of the pass emitting this diagnostic. If this name /// \p PassName is the name of the pass emitting this diagnostic. If this name
/// matches the regular expression given in -Rpass-analysis=, then the /// matches the regular expression given in -Rpass-analysis=, then the
/// diagnostic will be emitted. \p RemarkName is a textual identifier for the /// diagnostic will be emitted. \p RemarkName is a textual identifier for the
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Linesprivate:
/// diagnostic. If line table information is available, the diagnostic will /// diagnostic. If line table information is available, the diagnostic will
/// include the source code location. \p Msg is the message to show. Note that /// include the source code location. \p Msg is the message to show. Note that
/// this class does not copy this message, so this reference must be valid for /// this class does not copy this message, so this reference must be valid for
/// the whole life time of the diagnostic. /// the whole life time of the diagnostic.
OptimizationRemarkAnalysis(const char *PassName, const Function &Fn, OptimizationRemarkAnalysis(const char *PassName, const Function &Fn,
const DiagnosticLocation &Loc, const Twine &Msg) const DiagnosticLocation &Loc, const Twine &Msg)
: DiagnosticInfoIROptimization(DK_OptimizationRemarkAnalysis, DS_Remark, : DiagnosticInfoIROptimization(DK_OptimizationRemarkAnalysis, DS_Remark,
PassName, Fn, Loc, Msg) {} PassName, Fn, Loc, Msg) {}
friend void emitOptimizationRemarkAnalysis(LLVMContext &Ctx,
const char *PassName,
const Function &Fn,
const DiagnosticLocation &Loc,
const Twine &Msg);
}; };
/// Diagnostic information for optimization analysis remarks related to /// Diagnostic information for optimization analysis remarks related to
/// floating-point non-commutativity. /// floating-point non-commutativity.
class OptimizationRemarkAnalysisFPCommute : public OptimizationRemarkAnalysis { class OptimizationRemarkAnalysisFPCommute : public OptimizationRemarkAnalysis {
public: public:
/// \p PassName is the name of the pass emitting this diagnostic. If this name /// \p PassName is the name of the pass emitting this diagnostic. If this name
/// matches the regular expression given in -Rpass-analysis=, then the /// matches the regular expression given in -Rpass-analysis=, then the
Show All 25 Linesprivate:
/// floating-point non-commutativity. Note that this class does not copy this /// floating-point non-commutativity. Note that this class does not copy this
/// message, so this reference must be valid for the whole life time of the /// message, so this reference must be valid for the whole life time of the
/// diagnostic. /// diagnostic.
OptimizationRemarkAnalysisFPCommute(const char *PassName, const Function &Fn, OptimizationRemarkAnalysisFPCommute(const char *PassName, const Function &Fn,
const DiagnosticLocation &Loc, const DiagnosticLocation &Loc,
const Twine &Msg) const Twine &Msg)
: OptimizationRemarkAnalysis(DK_OptimizationRemarkAnalysisFPCommute, : OptimizationRemarkAnalysis(DK_OptimizationRemarkAnalysisFPCommute,
PassName, Fn, Loc, Msg) {} PassName, Fn, Loc, Msg) {}
friend void emitOptimizationRemarkAnalysisFPCommute(
LLVMContext &Ctx, const char *PassName, const Function &Fn,
const DiagnosticLocation &Loc, const Twine &Msg);
}; };
/// Diagnostic information for optimization analysis remarks related to /// Diagnostic information for optimization analysis remarks related to
/// pointer aliasing. /// pointer aliasing.
class OptimizationRemarkAnalysisAliasing : public OptimizationRemarkAnalysis { class OptimizationRemarkAnalysisAliasing : public OptimizationRemarkAnalysis {
public: public:
/// \p PassName is the name of the pass emitting this diagnostic. If this name /// \p PassName is the name of the pass emitting this diagnostic. If this name
/// matches the regular expression given in -Rpass-analysis=, then the /// matches the regular expression given in -Rpass-analysis=, then the
Show All 24 Linesprivate:
/// pointer aliasing legality. Note that this class does not copy this /// pointer aliasing legality. Note that this class does not copy this
/// message, so this reference must be valid for the whole life time of the /// message, so this reference must be valid for the whole life time of the
/// diagnostic. /// diagnostic.
OptimizationRemarkAnalysisAliasing(const char *PassName, const Function &Fn, OptimizationRemarkAnalysisAliasing(const char *PassName, const Function &Fn,
const DiagnosticLocation &Loc, const DiagnosticLocation &Loc,
const Twine &Msg) const Twine &Msg)
: OptimizationRemarkAnalysis(DK_OptimizationRemarkAnalysisAliasing, : OptimizationRemarkAnalysis(DK_OptimizationRemarkAnalysisAliasing,
PassName, Fn, Loc, Msg) {} PassName, Fn, Loc, Msg) {}
friend void emitOptimizationRemarkAnalysisAliasing(
LLVMContext &Ctx, const char *PassName, const Function &Fn,
const DiagnosticLocation &Loc, const Twine &Msg);
}; };
/// Diagnostic information for machine IR parser. /// Diagnostic information for machine IR parser.
class DiagnosticInfoMIRParser : public DiagnosticInfo { class DiagnosticInfoMIRParser : public DiagnosticInfo {
const SMDiagnostic &Diagnostic; const SMDiagnostic &Diagnostic;
public: public:
DiagnosticInfoMIRParser(DiagnosticSeverity Severity, DiagnosticInfoMIRParser(DiagnosticSeverity Severity,
Show All 26 Linespublic:
static bool classof(const DiagnosticInfo *DI) { static bool classof(const DiagnosticInfo *DI) {
return DI->getKind() == DK_ISelFallback; return DI->getKind() == DK_ISelFallback;
} }
}; };
// Create wrappers for C Binding types (see CBindingWrapping.h). // Create wrappers for C Binding types (see CBindingWrapping.h).
DEFINE_SIMPLE_CONVERSION_FUNCTIONS(DiagnosticInfo, LLVMDiagnosticInfoRef) DEFINE_SIMPLE_CONVERSION_FUNCTIONS(DiagnosticInfo, LLVMDiagnosticInfoRef)
/// \brief Legacy interface to emit an optimization-applied message. Use
/// (Machine)OptimizationRemarkEmitter instead.
///
/// \p PassName is the name of the pass emitting the message. If -Rpass= is
/// given and \p PassName matches the regular expression in -Rpass, then the
/// remark will be emitted. \p Fn is the function triggering the remark, \p Loc
/// is the debug location where the diagnostic is generated. \p Msg is the
/// message string to use.
void emitOptimizationRemark(LLVMContext &Ctx, const char *PassName,
const Function &Fn, const DiagnosticLocation &Loc,
const Twine &Msg);
/// \brief Legacy interface to emit an optimization-missed message. Use
/// (Machine)OptimizationRemarkEmitter instead.
///
/// \p PassName is the name of the pass emitting the message. If -Rpass-missed=
/// is given and \p PassName matches the regular expression in -Rpass, then the
/// remark will be emitted. \p Fn is the function triggering the remark, \p Loc
/// is the debug location where the diagnostic is generated. \p Msg is the
/// message string to use.
void emitOptimizationRemarkMissed(LLVMContext &Ctx, const char *PassName,
const Function &Fn,
const DiagnosticLocation &Loc,
const Twine &Msg);
/// \brief Legacy interface to emit an optimization analysis remark message.
/// Use (Machine)OptimizationRemarkEmitter instead.
///
/// \p PassName is the name of the pass emitting the message. If
/// -Rpass-analysis= is given and \p PassName matches the regular expression in
/// -Rpass, then the remark will be emitted. \p Fn is the function triggering
/// the remark, \p Loc is the debug location where the diagnostic is
/// generated. \p Msg is the message string to use.
void emitOptimizationRemarkAnalysis(LLVMContext &Ctx, const char *PassName,
const Function &Fn,
const DiagnosticLocation &Loc,
const Twine &Msg);
/// \brief Legacy interface to emit an optimization analysis remark related to
/// messages about floating-point non-commutativity. Use
/// (Machine)OptimizationRemarkEmitter instead.
///
/// \p PassName is the name of the pass emitting the message. If
/// -Rpass-analysis= is given and \p PassName matches the regular expression in
/// -Rpass, then the remark will be emitted. \p Fn is the function triggering
/// the remark, \p Loc is the debug location where the diagnostic is
/// generated. \p Msg is the message string to use.
void emitOptimizationRemarkAnalysisFPCommute(LLVMContext &Ctx,
const char *PassName,
const Function &Fn,
const DiagnosticLocation &Loc,
const Twine &Msg);
/// \brief Legacy interface to emit an optimization analysis remark related to
/// messages about pointer aliasing. Use (Machine)OptimizationRemarkEmitter
/// instead.
///
/// \p PassName is the name of the pass emitting the message.
/// If -Rpass-analysis= is given and \p PassName matches the regular expression
/// in -Rpass, then the remark will be emitted. \p Fn is the function triggering
/// the remark, \p Loc is the debug location where the diagnostic is generated.
/// \p Msg is the message string to use.
void emitOptimizationRemarkAnalysisAliasing(LLVMContext &Ctx,
const char *PassName,
const Function &Fn,
const DiagnosticLocation &Loc,
const Twine &Msg);
/// Diagnostic information for optimization failures. /// Diagnostic information for optimization failures.
class DiagnosticInfoOptimizationFailure : public DiagnosticInfoIROptimization { class DiagnosticInfoOptimizationFailure : public DiagnosticInfoIROptimization {
public: public:
/// \p Fn is the function where the diagnostic is being emitted. \p Loc is /// \p Fn is the function where the diagnostic is being emitted. \p Loc is
/// the location information to use in the diagnostic. If line table /// the location information to use in the diagnostic. If line table
/// information is available, the diagnostic will include the source code /// information is available, the diagnostic will include the source code
/// location. \p Msg is the message to show. Note that this class does not /// location. \p Msg is the message to show. Note that this class does not
/// copy this message, so this reference must be valid for the whole life time /// copy this message, so this reference must be valid for the whole life time
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

llvm/trunk/lib/IR/DiagnosticInfo.cpp

Show All 39 Lines
#include <string> #include <string>
using namespace llvm; using namespace llvm;
namespace { namespace {
/// \brief Regular expression corresponding to the value given in one of the /// \brief Regular expression corresponding to the value given in one of the
/// -pass-remarks* command line flags. Passes whose name matches this regexp /// -pass-remarks* command line flags. Passes whose name matches this regexp
/// will emit a diagnostic when calling the associated diagnostic function /// will emit a diagnostic via ORE->emit(...);
/// (emitOptimizationRemark, emitOptimizationRemarkMissed or
/// emitOptimizationRemarkAnalysis).
struct PassRemarksOpt { struct PassRemarksOpt {
std::shared_ptr<Regex> Pattern; std::shared_ptr<Regex> Pattern;
void operator=(const std::string &Val) { void operator=(const std::string &Val) {
// Create a regexp object to match pass names for emitOptimizationRemark.
if (!Val.empty()) { if (!Val.empty()) {
Pattern = std::make_shared<Regex>(Val); Pattern = std::make_shared<Regex>(Val);
std::string RegexError; std::string RegexError;
if (!Pattern->isValid(RegexError)) if (!Pattern->isValid(RegexError))
report_fatal_error("Invalid regular expression '" + Val + report_fatal_error("Invalid regular expression '" + Val +
"' in -pass-remarks: " + RegexError, "' in -pass-remarks: " + RegexError,
false); false);
} }
} }
}; };
} // end anonymous namespace } // end anonymous namespace
static PassRemarksOpt PassRemarksOptLoc; static PassRemarksOpt PassRemarksOptLoc;
static PassRemarksOpt PassRemarksMissedOptLoc; static PassRemarksOpt PassRemarksMissedOptLoc;
static PassRemarksOpt PassRemarksAnalysisOptLoc; static PassRemarksOpt PassRemarksAnalysisOptLoc;
// -pass-remarks // -pass-remarks
// Command line flag to enable emitOptimizationRemark() // Command line flag to enable optimization remarks
static cl::opt<PassRemarksOpt, true, cl::parser<std::string>> static cl::opt<PassRemarksOpt, true, cl::parser<std::string>>
PassRemarks("pass-remarks", cl::value_desc("pattern"), PassRemarks("pass-remarks", cl::value_desc("pattern"),
cl::desc("Enable optimization remarks from passes whose name match " cl::desc("Enable optimization remarks from passes whose name match "
"the given regular expression"), "the given regular expression"),
cl::Hidden, cl::location(PassRemarksOptLoc), cl::ValueRequired, cl::Hidden, cl::location(PassRemarksOptLoc), cl::ValueRequired,
cl::ZeroOrMore); cl::ZeroOrMore);
// -pass-remarks-missed // -pass-remarks-missed
// Command line flag to enable emitOptimizationRemarkMissed() // Command line flag to enable missed optimization remarks
static cl::opt<PassRemarksOpt, true, cl::parser<std::string>> PassRemarksMissed( static cl::opt<PassRemarksOpt, true, cl::parser<std::string>> PassRemarksMissed(
"pass-remarks-missed", cl::value_desc("pattern"), "pass-remarks-missed", cl::value_desc("pattern"),
cl::desc("Enable missed optimization remarks from passes whose name match " cl::desc("Enable missed optimization remarks from passes whose name match "
"the given regular expression"), "the given regular expression"),
cl::Hidden, cl::location(PassRemarksMissedOptLoc), cl::ValueRequired, cl::Hidden, cl::location(PassRemarksMissedOptLoc), cl::ValueRequired,
cl::ZeroOrMore); cl::ZeroOrMore);
// -pass-remarks-analysis // -pass-remarks-analysis
// Command line flag to enable emitOptimizationRemarkAnalysis() // Command line flag to enable optimization analysis remarks
static cl::opt<PassRemarksOpt, true, cl::parser<std::string>> static cl::opt<PassRemarksOpt, true, cl::parser<std::string>>
PassRemarksAnalysis( PassRemarksAnalysis(
"pass-remarks-analysis", cl::value_desc("pattern"), "pass-remarks-analysis", cl::value_desc("pattern"),
cl::desc( cl::desc(
"Enable optimization analysis remarks from passes whose name match " "Enable optimization analysis remarks from passes whose name match "
"the given regular expression"), "the given regular expression"),
cl::Hidden, cl::location(PassRemarksAnalysisOptLoc), cl::ValueRequired, cl::Hidden, cl::location(PassRemarksAnalysisOptLoc), cl::ValueRequired,
cl::ZeroOrMore); cl::ZeroOrMore);
▲ Show 20 Lines • Show All 228 Lines • ▼ Show 20 Linesbool OptimizationRemarkAnalysis::isEnabled(StringRef PassName) {
return PassRemarksAnalysisOptLoc.Pattern && return PassRemarksAnalysisOptLoc.Pattern &&
PassRemarksAnalysisOptLoc.Pattern->match(PassName); PassRemarksAnalysisOptLoc.Pattern->match(PassName);
} }
void DiagnosticInfoMIRParser::print(DiagnosticPrinter &DP) const { void DiagnosticInfoMIRParser::print(DiagnosticPrinter &DP) const {
DP << Diagnostic; DP << Diagnostic;
} }
void llvm::emitOptimizationRemark(LLVMContext &Ctx, const char *PassName,
const Function &Fn,
const DiagnosticLocation &Loc,
const Twine &Msg) {
Ctx.diagnose(OptimizationRemark(PassName, Fn, Loc, Msg));
}
void llvm::emitOptimizationRemarkMissed(LLVMContext &Ctx, const char *PassName,
const Function &Fn,
const DiagnosticLocation &Loc,
const Twine &Msg) {
Ctx.diagnose(OptimizationRemarkMissed(PassName, Fn, Loc, Msg));
}
void llvm::emitOptimizationRemarkAnalysis(LLVMContext &Ctx,
const char *PassName,
const Function &Fn,
const DiagnosticLocation &Loc,
const Twine &Msg) {
Ctx.diagnose(OptimizationRemarkAnalysis(PassName, Fn, Loc, Msg));
}
void llvm::emitOptimizationRemarkAnalysisFPCommute(
LLVMContext &Ctx, const char *PassName, const Function &Fn,
const DiagnosticLocation &Loc, const Twine &Msg) {
Ctx.diagnose(OptimizationRemarkAnalysisFPCommute(PassName, Fn, Loc, Msg));
}
void llvm::emitOptimizationRemarkAnalysisAliasing(LLVMContext &Ctx,
const char *PassName,
const Function &Fn,
const DiagnosticLocation &Loc,
const Twine &Msg) {
Ctx.diagnose(OptimizationRemarkAnalysisAliasing(PassName, Fn, Loc, Msg));
}
DiagnosticInfoOptimizationFailure::DiagnosticInfoOptimizationFailure( DiagnosticInfoOptimizationFailure::DiagnosticInfoOptimizationFailure(
const char *PassName, StringRef RemarkName, const DiagnosticLocation &Loc, const char *PassName, StringRef RemarkName, const DiagnosticLocation &Loc,
const Value *CodeRegion) const Value *CodeRegion)
: DiagnosticInfoIROptimization( : DiagnosticInfoIROptimization(
DK_OptimizationFailure, DS_Warning, PassName, RemarkName, DK_OptimizationFailure, DS_Warning, PassName, RemarkName,
*cast<BasicBlock>(CodeRegion)->getParent(), Loc, CodeRegion) {} *cast<BasicBlock>(CodeRegion)->getParent(), Loc, CodeRegion) {}
bool DiagnosticInfoOptimizationFailure::isEnabled() const { bool DiagnosticInfoOptimizationFailure::isEnabled() const {
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines