replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

[Remarks] Refactor optimization remarks setup 

* Add a common function to setup opt-remarks
* Rename common options to the same names
* Add error types to distinguish between file errors and regex errors

llvm-svn: 363328
This commit is contained in:
Francis Visoiu Mistrih 2019-06-13 21:46:57 +00:00
parent a5b12be60f
commit 6e6e3af55b
12 changed files with 182 additions and 162 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
clang/lib/CodeGen/CodeGenAction.cpp
View File

@ -262,35 +262,32 @@ namespace clang {
Ctx.getDiagnosticHandler();
Ctx.setDiagnosticHandler(llvm::make_unique<ClangDiagnosticHandler>(
CodeGenOpts, this));
Ctx.setDiagnosticsHotnessRequested(CodeGenOpts.DiagnosticsWithHotness);
if (CodeGenOpts.DiagnosticsHotnessThreshold != 0)
Ctx.setDiagnosticsHotnessThreshold(
Expected<std::unique_ptr<llvm::ToolOutputFile>> OptRecordFileOrErr =
setupOptimizationRemarks(Ctx, CodeGenOpts.OptRecordFile,
CodeGenOpts.OptRecordPasses,
CodeGenOpts.DiagnosticsWithHotness,
CodeGenOpts.DiagnosticsHotnessThreshold);
std::unique_ptr<llvm::ToolOutputFile> OptRecordFile;
if (!CodeGenOpts.OptRecordFile.empty()) {
std::error_code EC;
OptRecordFile = llvm::make_unique<llvm::ToolOutputFile>(
CodeGenOpts.OptRecordFile, EC, sys::fs::F_None);
if (EC) {
Diags.Report(diag::err_cannot_open_file) <<
CodeGenOpts.OptRecordFile << EC.message();
if (Error E = OptRecordFileOrErr.takeError()) {
handleAllErrors(
std::move(E),
[&](const RemarkSetupFileError &E) {
Diags.Report(diag::err_cannot_open_file)
<< CodeGenOpts.OptRecordFile << E.message();
},
[&](const RemarkSetupPatternError &E) {
Diags.Report(diag::err_drv_optimization_remark_pattern)
<< E.message() << CodeGenOpts.OptRecordPasses;
});
return;
}
std::unique_ptr<llvm::ToolOutputFile> OptRecordFile =
std::move(*OptRecordFileOrErr);
Ctx.setRemarkStreamer(llvm::make_unique<RemarkStreamer>(
CodeGenOpts.OptRecordFile,
llvm::make_unique<remarks::YAMLSerializer>(OptRecordFile->os())));
if (!CodeGenOpts.OptRecordPasses.empty())
if (Error E = Ctx.getRemarkStreamer()->setFilter(
CodeGenOpts.OptRecordPasses))
Diags.Report(diag::err_drv_optimization_remark_pattern)
<< toString(std::move(E)) << CodeGenOpts.OptRecordPasses;
if (CodeGenOpts.getProfileUse() != CodeGenOptions::ProfileNone)
if (OptRecordFile &&
CodeGenOpts.getProfileUse() != CodeGenOptions::ProfileNone)
Ctx.setDiagnosticsHotnessRequested(true);
}
// Link each LinkModule into our module.
if (LinkInModules())

28
llvm/include/llvm/IR/RemarkStreamer.h
View File

@ -17,6 +17,7 @@
#include "llvm/Remarks/RemarkSerializer.h"
#include "llvm/Support/Error.h"
#include "llvm/Support/Regex.h"
#include "llvm/Support/ToolOutputFile.h"
#include "llvm/Support/raw_ostream.h"
#include <string>
#include <vector>
@ -57,6 +58,33 @@ public:
/// Emit a diagnostic through the streamer.
void emit(const DiagnosticInfoOptimizationBase &Diag);
};
template <typename ThisError>
struct RemarkSetupErrorInfo : public ErrorInfo<ThisError> {
Error E;
RemarkSetupErrorInfo(Error E) : E(std::move(E)) {}
void log(raw_ostream &OS) const override { OS << E; }
std::error_code convertToErrorCode() const override {
return errorToErrorCode(E);
}
};
struct RemarkSetupFileError : RemarkSetupErrorInfo<RemarkSetupFileError> {
static char ID;
using RemarkSetupErrorInfo<RemarkSetupFileError>::RemarkSetupErrorInfo;
};
struct RemarkSetupPatternError : RemarkSetupErrorInfo<RemarkSetupPatternError> {
static char ID;
using RemarkSetupErrorInfo<RemarkSetupPatternError>::RemarkSetupErrorInfo;
};
/// Setup optimization remarks.
Expected<std::unique_ptr<ToolOutputFile>>
setupOptimizationRemarks(LLVMContext &Context, StringRef RemarksFilename,
StringRef RemarksPasses, bool RemarksWithHotness,
unsigned RemarksHotnessThreshold = 0);
} // end namespace llvm
#endif // LLVM_IR_REMARKSTREAMER_H

6
llvm/include/llvm/LTO/LTO.h
View File

@ -84,9 +84,9 @@ std::string getThinLTOOutputFile(const std::string &Path,
/// Setup optimization remarks.
Expected<std::unique_ptr<ToolOutputFile>>
setupOptimizationRemarks(LLVMContext &Context, StringRef LTORemarksFilename,
StringRef LTORemarksPasses,
bool LTOPassRemarksWithHotness, int Count = -1);
setupOptimizationRemarks(LLVMContext &Context, StringRef RemarksFilename,
StringRef RemarksPasses, bool RemarksWithHotness,
int Count = -1);
/// Setups the output file for saving statistics.
Expected<std::unique_ptr<ToolOutputFile>>

35
llvm/lib/IR/RemarkStreamer.cpp
View File

@ -106,3 +106,38 @@ void RemarkStreamer::emit(const DiagnosticInfoOptimizationBase &Diag) {
// Then, emit the remark through the serializer.
Serializer->emit(R);
}
char RemarkSetupFileError::ID = 0;
char RemarkSetupPatternError::ID = 0;
Expected<std::unique_ptr<ToolOutputFile>>
llvm::setupOptimizationRemarks(LLVMContext &Context, StringRef RemarksFilename,
StringRef RemarksPasses, bool RemarksWithHotness,
unsigned RemarksHotnessThreshold) {
if (RemarksWithHotness)
Context.setDiagnosticsHotnessRequested(true);
if (RemarksHotnessThreshold)
Context.setDiagnosticsHotnessThreshold(RemarksHotnessThreshold);
if (RemarksFilename.empty())
return nullptr;
std::error_code EC;
auto RemarksFile =
llvm::make_unique<ToolOutputFile>(RemarksFilename, EC, sys::fs::F_None);
// We don't use llvm::FileError here because some diagnostics want the file
// name separately.
if (EC)
return errorCodeToError(EC);
Context.setRemarkStreamer(llvm::make_unique<RemarkStreamer>(
RemarksFilename,
llvm::make_unique<remarks::YAMLSerializer>(RemarksFile->os())));
if (!RemarksPasses.empty())
if (Error E = Context.getRemarkStreamer()->setFilter(RemarksPasses))
return std::move(E);
return std::move(RemarksFile);
}

36
llvm/lib/LTO/LTO.cpp
View File

@ -1338,34 +1338,22 @@ Error LTO::runThinLTO(AddStreamFn AddStream, NativeObjectCache Cache,
}
Expected<std::unique_ptr<ToolOutputFile>>
lto::setupOptimizationRemarks(LLVMContext &Context,
StringRef LTORemarksFilename,
StringRef LTORemarksPasses,
bool LTOPassRemarksWithHotness, int Count) {
if (LTOPassRemarksWithHotness)
Context.setDiagnosticsHotnessRequested(true);
if (LTORemarksFilename.empty())
return nullptr;
std::string Filename = LTORemarksFilename;
if (Count != -1)
lto::setupOptimizationRemarks(LLVMContext &Context, StringRef RemarksFilename,
StringRef RemarksPasses, bool RemarksWithHotness,
int Count) {
std::string Filename = RemarksFilename;
if (!Filename.empty() && Count != -1)
Filename += ".thin." + llvm::utostr(Count) + ".yaml";
std::error_code EC;
auto DiagnosticFile =
llvm::make_unique<ToolOutputFile>(Filename, EC, sys::fs::F_None);
if (EC)
return errorCodeToError(EC);
Context.setRemarkStreamer(llvm::make_unique<RemarkStreamer>(
Filename,
llvm::make_unique<remarks::YAMLSerializer>(DiagnosticFile->os())));
if (!LTORemarksPasses.empty())
if (Error E = Context.getRemarkStreamer()->setFilter(LTORemarksPasses))
auto ResultOrErr = llvm::setupOptimizationRemarks(
Context, Filename, RemarksPasses, RemarksWithHotness);
if (Error E = ResultOrErr.takeError())
return std::move(E);
DiagnosticFile->keep();
return std::move(DiagnosticFile);
if (*ResultOrErr)
(*ResultOrErr)->keep();
return ResultOrErr;
}
Expected<std::unique_ptr<ToolOutputFile>>

3
llvm/lib/LTO/LTOBackend.cpp
View File

@ -22,6 +22,7 @@
#include "llvm/Bitcode/BitcodeWriter.h"
#include "llvm/IR/LegacyPassManager.h"
#include "llvm/IR/PassManager.h"
#include "llvm/IR/RemarkStreamer.h"
#include "llvm/IR/Verifier.h"
#include "llvm/LTO/LTO.h"
#include "llvm/MC/SubtargetFeature.h"
@ -32,9 +33,9 @@
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/Path.h"
#include "llvm/Support/Program.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Support/TargetRegistry.h"
#include "llvm/Support/ThreadPool.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Transforms/IPO.h"
#include "llvm/Transforms/IPO/PassManagerBuilder.h"

21
llvm/lib/LTO/LTOCodeGenerator.cpp
View File

@ -33,6 +33,7 @@
#include "llvm/IR/Mangler.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/PassTimingInfo.h"
#include "llvm/IR/RemarkStreamer.h"
#include "llvm/IR/Verifier.h"
#include "llvm/InitializePasses.h"
#include "llvm/LTO/LTO.h"
@ -80,22 +81,22 @@ cl::opt<bool> LTODiscardValueNames(
#endif
cl::Hidden);
cl::opt<bool> RemarksWithHotness(
"lto-pass-remarks-with-hotness",
cl::desc("With PGO, include profile count in optimization remarks"),
cl::Hidden);
cl::opt<std::string>
LTORemarksFilename("lto-pass-remarks-output",
RemarksFilename("lto-pass-remarks-output",
cl::desc("Output filename for pass remarks"),
cl::value_desc("filename"));
cl::opt<std::string>
LTORemarksPasses("lto-pass-remarks-filter",
cl::desc("Only record optimization remarks from passes "
"whose names match the given regular expression"),
RemarksPasses("lto-pass-remarks-filter",
cl::desc("Only record optimization remarks from passes whose "
"names match the given regular expression"),
cl::value_desc("regex"));
cl::opt<bool> LTOPassRemarksWithHotness(
"lto-pass-remarks-with-hotness",
cl::desc("With PGO, include profile count in optimization remarks"),
cl::Hidden);
cl::opt<std::string> LTOStatsFile(
"lto-stats-file",
cl::desc("Save statistics to the specified file"),
@ -517,7 +518,7 @@ bool LTOCodeGenerator::optimize(bool DisableVerify, bool DisableInline,
return false;
auto DiagFileOrErr = lto::setupOptimizationRemarks(
Context, LTORemarksFilename, LTORemarksPasses, LTOPassRemarksWithHotness);
Context, RemarksFilename, RemarksPasses, RemarksWithHotness);
if (!DiagFileOrErr) {
errs() << "Error: " << toString(DiagFileOrErr.takeError()) << "\n";
report_fatal_error("Can't get an output file for the remarks");

11
llvm/lib/LTO/ThinLTOCodeGenerator.cpp
View File

@ -29,6 +29,7 @@
#include "llvm/IR/LegacyPassManager.h"
#include "llvm/IR/Mangler.h"
#include "llvm/IR/PassTimingInfo.h"
#include "llvm/IR/RemarkStreamer.h"
#include "llvm/IR/Verifier.h"
#include "llvm/IRReader/IRReader.h"
#include "llvm/LTO/LTO.h"
@ -69,9 +70,9 @@ using namespace llvm;
namespace llvm {
// Flags -discard-value-names, defined in LTOCodeGenerator.cpp
extern cl::opt<bool> LTODiscardValueNames;
extern cl::opt<std::string> LTORemarksFilename;
extern cl::opt<std::string> LTORemarksPasses;
extern cl::opt<bool> LTOPassRemarksWithHotness;
extern cl::opt<std::string> RemarksFilename;
extern cl::opt<std::string> RemarksPasses;
extern cl::opt<bool> RemarksWithHotness;
}
namespace {
@ -1019,8 +1020,8 @@ void ThinLTOCodeGenerator::run() {
Context.setDiscardValueNames(LTODiscardValueNames);
Context.enableDebugTypeODRUniquing();
auto DiagFileOrErr = lto::setupOptimizationRemarks(
Context, LTORemarksFilename, LTORemarksPasses,
LTOPassRemarksWithHotness, count);
Context, RemarksFilename, RemarksPasses,
RemarksWithHotness, count);
if (!DiagFileOrErr) {
errs() << "Error: " << toString(DiagFileOrErr.takeError()) << "\n";
report_fatal_error("ThinLTO: Can't get an output file for the "

18
llvm/tools/gold/gold-plugin.cpp
View File

@ -206,9 +206,9 @@ namespace options {
static std::string stats_file;
// Optimization remarks filename, accepted passes and hotness options
static std::string OptRemarksFilename;
static std::string OptRemarksFilter;
static bool OptRemarksWithHotness = false;
static std::string RemarksFilename;
static std::string RemarksPasses;
static bool RemarksWithHotness = false;
// Context sensitive PGO options.
static std::string cs_profile_path;
@ -285,11 +285,11 @@ namespace options {
} else if (opt.startswith("dwo_dir=")) {
dwo_dir = opt.substr(strlen("dwo_dir="));
} else if (opt.startswith("opt-remarks-filename=")) {
OptRemarksFilename = opt.substr(strlen("opt-remarks-filename="));
RemarksFilename = opt.substr(strlen("opt-remarks-filename="));
} else if (opt.startswith("opt-remarks-passes=")) {
OptRemarksFilter = opt.substr(strlen("opt-remarks-passes="));
RemarksPasses = opt.substr(strlen("opt-remarks-passes="));
} else if (opt == "opt-remarks-with-hotness") {
OptRemarksWithHotness = true;
RemarksWithHotness = true;
} else if (opt.startswith("stats-file=")) {
stats_file = opt.substr(strlen("stats-file="));
} else {
@ -910,9 +910,9 @@ static std::unique_ptr<LTO> createLTO(IndexWriteCallback OnIndexWrite,
Conf.DwoDir = options::dwo_dir;
// Set up optimization remarks handling.
Conf.RemarksFilename = options::OptRemarksFilename;
Conf.RemarksPasses = options::OptRemarksFilter;
Conf.RemarksWithHotness = options::OptRemarksWithHotness;
Conf.RemarksFilename = options::RemarksFilename;
Conf.RemarksPasses = options::RemarksPasses;
Conf.RemarksWithHotness = options::RemarksWithHotness;
// Use new pass manager if set in driver
Conf.UseNewPM = options::new_pass_manager;

44
llvm/tools/llc/llc.cpp
View File

@ -133,19 +133,20 @@ static cl::opt<bool> DiscardValueNames(
static cl::list<std::string> IncludeDirs("I", cl::desc("include search path"));
static cl::opt<bool> PassRemarksWithHotness(
static cl::opt<bool> RemarksWithHotness(
"pass-remarks-with-hotness",
cl::desc("With PGO, include profile count in optimization remarks"),
cl::Hidden);
static cl::opt<unsigned> PassRemarksHotnessThreshold(
"pass-remarks-hotness-threshold",
cl::desc("Minimum profile count required for an optimization remark to be output"),
static cl::opt<unsigned>
RemarksHotnessThreshold("pass-remarks-hotness-threshold",
cl::desc("Minimum profile count required for "
"an optimization remark to be output"),
cl::Hidden);
static cl::opt<std::string>
RemarksFilename("pass-remarks-output",
cl::desc("YAML output filename for pass remarks"),
cl::desc("Output filename for pass remarks"),
cl::value_desc("filename"));
static cl::opt<std::string>
@ -326,31 +327,14 @@ int main(int argc, char **argv) {
llvm::make_unique<LLCDiagnosticHandler>(&HasError));
Context.setInlineAsmDiagnosticHandler(InlineAsmDiagHandler, &HasError);
if (PassRemarksWithHotness)
Context.setDiagnosticsHotnessRequested(true);
if (PassRemarksHotnessThreshold)
Context.setDiagnosticsHotnessThreshold(PassRemarksHotnessThreshold);
std::unique_ptr<ToolOutputFile> YamlFile;
if (RemarksFilename != "") {
std::error_code EC;
YamlFile =
llvm::make_unique<ToolOutputFile>(RemarksFilename, EC, sys::fs::F_None);
if (EC) {
WithColor::error(errs(), argv[0]) << EC.message() << '\n';
Expected<std::unique_ptr<ToolOutputFile>> RemarksFileOrErr =
setupOptimizationRemarks(Context, RemarksFilename, RemarksPasses,
RemarksWithHotness, RemarksHotnessThreshold);
if (Error E = RemarksFileOrErr.takeError()) {
WithColor::error(errs(), argv[0]) << toString(std::move(E)) << '\n';
return 1;
}
Context.setRemarkStreamer(llvm::make_unique<RemarkStreamer>(
RemarksFilename,
llvm::make_unique<remarks::YAMLSerializer>(YamlFile->os())));
if (!RemarksPasses.empty())
if (Error E = Context.getRemarkStreamer()->setFilter(RemarksPasses)) {
WithColor::error(errs(), argv[0]) << E << '\n';
return 1;
}
}
std::unique_ptr<ToolOutputFile> RemarksFile = std::move(*RemarksFileOrErr);
if (InputLanguage != "" && InputLanguage != "ir" &&
InputLanguage != "mir") {
@ -365,8 +349,8 @@ int main(int argc, char **argv) {
if (int RetVal = compileModule(argv, Context))
return RetVal;
if (YamlFile)
YamlFile->keep();
if (RemarksFile)
RemarksFile->keep();
return 0;
}

27
llvm/tools/llvm-lto2/llvm-lto2.cpp
View File

@ -91,19 +91,20 @@ static cl::opt<std::string> DefaultTriple(
cl::desc(
"Replace unspecified target triples in input files with this triple"));
static cl::opt<std::string>
OptRemarksOutput("pass-remarks-output",
cl::desc("YAML output file for optimization remarks"));
static cl::opt<bool> OptRemarksWithHotness(
static cl::opt<bool> RemarksWithHotness(
"pass-remarks-with-hotness",
cl::desc("Whether to include hotness informations in the remarks.\n"
"Has effect only if -pass-remarks-output is specified."));
cl::desc("With PGO, include profile count in optimization remarks"),
cl::Hidden);
static cl::opt<std::string>
OptRemarksPasses("pass-remarks-filter",
cl::desc("Only record optimization remarks from passes "
"whose names match the given regular expression"),
RemarksFilename("pass-remarks-output",
cl::desc("Output filename for pass remarks"),
cl::value_desc("filename"));
static cl::opt<std::string>
RemarksPasses("pass-remarks-filter",
cl::desc("Only record optimization remarks from passes whose "
"names match the given regular expression"),
cl::value_desc("regex"));
static cl::opt<std::string>
@ -225,9 +226,9 @@ static int run(int argc, char **argv) {
"Config::addSaveTemps failed");
// Optimization remarks.
Conf.RemarksFilename = OptRemarksOutput;
Conf.RemarksPasses = OptRemarksPasses;
Conf.RemarksWithHotness = OptRemarksWithHotness;
Conf.RemarksFilename = RemarksFilename;
Conf.RemarksPasses = RemarksPasses;
Conf.RemarksWithHotness = RemarksWithHotness;
Conf.SampleProfile = SamplePGOFile;
Conf.CSIRProfile = CSPGOFile;

50
llvm/tools/opt/opt.cpp
View File

@ -251,19 +251,20 @@ static cl::opt<bool> Coroutines(
cl::desc("Enable coroutine passes."),
cl::init(false), cl::Hidden);
static cl::opt<bool> PassRemarksWithHotness(
static cl::opt<bool> RemarksWithHotness(
"pass-remarks-with-hotness",
cl::desc("With PGO, include profile count in optimization remarks"),
cl::Hidden);
static cl::opt<unsigned> PassRemarksHotnessThreshold(
"pass-remarks-hotness-threshold",
cl::desc("Minimum profile count required for an optimization remark to be output"),
static cl::opt<unsigned>
RemarksHotnessThreshold("pass-remarks-hotness-threshold",
cl::desc("Minimum profile count required for "
"an optimization remark to be output"),
cl::Hidden);
static cl::opt<std::string>
RemarksFilename("pass-remarks-output",
cl::desc("YAML output filename for pass remarks"),
cl::desc("Output filename for pass remarks"),
cl::value_desc("filename"));
static cl::opt<std::string>
@ -549,31 +550,14 @@ int main(int argc, char **argv) {
if (!DisableDITypeMap)
Context.enableDebugTypeODRUniquing();
if (PassRemarksWithHotness)
Context.setDiagnosticsHotnessRequested(true);
if (PassRemarksHotnessThreshold)
Context.setDiagnosticsHotnessThreshold(PassRemarksHotnessThreshold);
std::unique_ptr<ToolOutputFile> OptRemarkFile;
if (RemarksFilename != "") {
std::error_code EC;
OptRemarkFile =
llvm::make_unique<ToolOutputFile>(RemarksFilename, EC, sys::fs::F_None);
if (EC) {
errs() << EC.message() << '\n';
Expected<std::unique_ptr<ToolOutputFile>> RemarksFileOrErr =
setupOptimizationRemarks(Context, RemarksFilename, RemarksPasses,
RemarksWithHotness, RemarksHotnessThreshold);
if (Error E = RemarksFileOrErr.takeError()) {
errs() << toString(std::move(E)) << '\n';
return 1;
}
Context.setRemarkStreamer(llvm::make_unique<RemarkStreamer>(
RemarksFilename,
llvm::make_unique<remarks::YAMLSerializer>(OptRemarkFile->os())));
if (!RemarksPasses.empty())
if (Error E = Context.getRemarkStreamer()->setFilter(RemarksPasses)) {
errs() << E << '\n';
return 1;
}
}
std::unique_ptr<ToolOutputFile> RemarksFile = std::move(*RemarksFileOrErr);
// Load the input module...
std::unique_ptr<Module> M =
@ -687,7 +671,7 @@ int main(int argc, char **argv) {
// string. Hand off the rest of the functionality to the new code for that
// layer.
return runPassPipeline(argv[0], *M, TM.get(), Out.get(), ThinLinkOut.get(),
OptRemarkFile.get(), PassPipeline, OK, VK,
RemarksFile.get(), PassPipeline, OK, VK,
PreserveAssemblyUseListOrder,
PreserveBitcodeUseListOrder, EmitSummaryIndex,
EmitModuleHash, EnableDebugify)
@ -923,8 +907,8 @@ int main(int argc, char **argv) {
"the compile-twice option\n";
Out->os() << BOS->str();
Out->keep();
if (OptRemarkFile)
OptRemarkFile->keep();
if (RemarksFile)
RemarksFile->keep();
return 1;
}
Out->os() << BOS->str();
@ -937,8 +921,8 @@ int main(int argc, char **argv) {
if (!NoOutput || PrintBreakpoints)
Out->keep();
if (OptRemarkFile)
OptRemarkFile->keep();
if (RemarksFile)
RemarksFile->keep();
if (ThinLinkOut)
ThinLinkOut->keep();