maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

[Remarks] Extend -fsave-optimization-record to specify the format 

Use -fsave-optimization-record=<format> to specify a different format
than the default, which is YAML.

For now, only YAML is supported.

llvm-svn: 363573
This commit is contained in:
Francis Visoiu Mistrih 2019-06-17 16:06:00 +00:00
parent 77bc3b6542
commit 34667519dc
33 changed files with 172 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
clang/docs/UsersManual.rst
View File

@ -324,13 +324,21 @@ output format of the diagnostics that it generates.
.. _opt_fsave-optimization-record:
**-fsave-optimization-record**
Write optimization remarks to a YAML file.
.. option:: -fsave-optimization-record[=<format>]
Write optimization remarks to a separate file.
This option, which defaults to off, controls whether Clang writes
optimization reports to a YAML file. By recording diagnostics in a file,
using a structured YAML format, users can parse or sort the remarks in a
convenient way.
optimization reports to a separate file. By recording diagnostics in a file,
users can parse or sort the remarks in a convenient way.
By default, the serialization format is YAML.
The supported serialization formats are:
- .. _opt_fsave_optimization_record_yaml:
``-fsave-optimization-record=yaml``: A structured YAML format.
.. _opt_foptimization-record-file:

3
clang/include/clang/Basic/CodeGenOptions.h
View File

@ -246,6 +246,9 @@ public:
/// records.
std::string OptRecordPasses;
/// The format used for serializing remarks (default: YAML)
std::string OptRecordFormat;
/// The name of the partition that symbols are assigned to, specified with
/// -fsymbol-partition (see https://lld.llvm.org/Partitions.html).
std::string SymbolPartition;

2
clang/include/clang/Basic/DiagnosticDriverKinds.td
View File

@ -230,6 +230,8 @@ def err_drv_emit_llvm_link : Error<
"-emit-llvm cannot be used when linking">;
def err_drv_optimization_remark_pattern : Error<
"in pattern '%1': %0">;
def err_drv_optimization_remark_format : Error<
"unknown remark serializer format: '%0'">;
def err_drv_no_neon_modifier : Error<"[no]neon is not accepted as modifier, please use [no]simd instead">;
def err_drv_invalid_omp_target : Error<"OpenMP target is invalid: '%0'">;
def err_drv_omp_host_ir_file_not_found : Error<

2
clang/include/clang/Driver/CC1Options.td
View File

@ -636,6 +636,8 @@ def opt_record_file : Separate<["-"], "opt-record-file">,
HelpText<"File name to use for YAML optimization record output">;
def opt_record_passes : Separate<["-"], "opt-record-passes">,
HelpText<"Only record remark information for passes whose names match the given regular expression">;
def opt_record_format : Separate<["-"], "opt-record-format">,
HelpText<"The format used for serializing remarks (default: YAML)">;
def print_stats : Flag<["-"], "print-stats">,
HelpText<"Print performance metrics and statistics">;

2
clang/include/clang/Driver/Options.td
View File

@ -1717,6 +1717,8 @@ def foperator_arrow_depth_EQ : Joined<["-"], "foperator-arrow-depth=">,
def fsave_optimization_record : Flag<["-"], "fsave-optimization-record">,
Group<f_Group>, HelpText<"Generate a YAML optimization record file">;
def fsave_optimization_record_EQ : Joined<["-"], "fsave-optimization-record=">,
Group<f_Group>, HelpText<"Generate an optimization record file in a specific format (default: YAML)">;
def fno_save_optimization_record : Flag<["-"], "fno-save-optimization-record">,
Group<f_Group>, Flags<[NoArgumentUnused]>;
def foptimization_record_file_EQ : Joined<["-"], "foptimization-record-file=">,

1
clang/lib/CodeGen/BackendUtil.cpp
View File

@ -1428,6 +1428,7 @@ static void runThinLTOBackend(ModuleSummaryIndex *CombinedIndex, Module *M,
Conf.RemarksWithHotness = CGOpts.DiagnosticsWithHotness;
Conf.RemarksFilename = CGOpts.OptRecordFile;
Conf.RemarksPasses = CGOpts.OptRecordPasses;
Conf.RemarksFormat = CGOpts.OptRecordFormat;
Conf.SplitDwarfFile = CGOpts.SplitDwarfFile;
Conf.SplitDwarfOutput = CGOpts.SplitDwarfOutput;
switch (Action) {

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

@ -266,6 +266,7 @@ namespace clang {
Expected<std::unique_ptr<llvm::ToolOutputFile>> OptRecordFileOrErr =
setupOptimizationRemarks(Ctx, CodeGenOpts.OptRecordFile,
CodeGenOpts.OptRecordPasses,
CodeGenOpts.OptRecordFormat,
CodeGenOpts.DiagnosticsWithHotness,
CodeGenOpts.DiagnosticsHotnessThreshold);
@ -279,6 +280,10 @@ namespace clang {
[&](const RemarkSetupPatternError &E) {
Diags.Report(diag::err_drv_optimization_remark_pattern)
<< E.message() << CodeGenOpts.OptRecordPasses;
},
[&](const RemarkSetupFormatError &E) {
Diags.Report(diag::err_drv_optimization_remark_format)
<< CodeGenOpts.OptRecordFormat;
});
return;
}

8
clang/lib/Driver/ToolChains/Clang.cpp
View File

@ -5079,6 +5079,8 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA,
if (Args.hasFlag(options::OPT_fsave_optimization_record,
options::OPT_foptimization_record_file_EQ,
options::OPT_fno_save_optimization_record, false) ||
Args.hasFlag(options::OPT_fsave_optimization_record_EQ,
options::OPT_fno_save_optimization_record, false) ||
Args.hasFlag(options::OPT_foptimization_record_passes_EQ,
options::OPT_fno_save_optimization_record, false)) {
CmdArgs.push_back("-opt-record-file");
@ -5119,6 +5121,12 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA,
CmdArgs.push_back("-opt-record-passes");
CmdArgs.push_back(A->getValue());
}
if (const Arg *A =
Args.getLastArg(options::OPT_fsave_optimization_record_EQ)) {
CmdArgs.push_back("-opt-record-format");
CmdArgs.push_back(A->getValue());
}
}
bool RewriteImports = Args.hasFlag(options::OPT_frewrite_imports,

9
clang/lib/Driver/ToolChains/Darwin.cpp
View File

@ -462,6 +462,7 @@ void darwin::Linker::ConstructJob(Compilation &C, const JobAction &JA,
// For LTO, pass the name of the optimization record file and other
// opt-remarks flags.
if (Args.hasFlag(options::OPT_fsave_optimization_record,
options::OPT_fsave_optimization_record_EQ,
options::OPT_fno_save_optimization_record, false)) {
CmdArgs.push_back("-mllvm");
CmdArgs.push_back("-lto-pass-remarks-output");
@ -492,6 +493,14 @@ void darwin::Linker::ConstructJob(Compilation &C, const JobAction &JA,
std::string("-lto-pass-remarks-filter=") + A->getValue();
CmdArgs.push_back(Args.MakeArgString(Passes));
}
if (const Arg *A =
Args.getLastArg(options::OPT_fsave_optimization_record_EQ)) {
CmdArgs.push_back("-mllvm");
std::string Format =
std::string("-lto-pass-remarks-format=") + A->getValue();
CmdArgs.push_back(Args.MakeArgString(Format));
}
}
// Propagate the -moutline flag to the linker in LTO.

5
clang/lib/Frontend/CompilerInvocation.cpp
View File

@ -1237,6 +1237,11 @@ static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK,
NeedLocTracking = true;
}
if (Arg *A = Args.getLastArg(OPT_opt_record_format)) {
Opts.OptRecordFormat = A->getValue();
NeedLocTracking = true;
}
if (Arg *A = Args.getLastArg(OPT_Rpass_EQ)) {
Opts.OptimizationRemarkPattern =
GenerateOptimizationRemarkRegex(Diags, Args, A);

2
clang/test/CodeGen/opt-record-MIR.c
View File

@ -5,6 +5,8 @@
// RUN: cat %t.yaml | FileCheck -check-prefix=YAML %s
// RUN: %clang_cc1 -triple arm64-apple-ios -S -o /dev/null %s -O2 -dwarf-column-info -opt-record-file %t.yaml -opt-record-passes asm-printer
// RUN: cat %t.yaml | FileCheck -check-prefix=PASSES %s
// RUN: %clang_cc1 -triple arm64-apple-ios -S -o /dev/null %s -O2 -dwarf-column-info -opt-record-file %t.yaml -opt-record-format yaml
// RUN: cat %t.yaml | FileCheck -check-prefix=YAML %s
void bar(float);

5
clang/test/CodeGen/opt-record.c
View File

@ -6,6 +6,9 @@
// RUN: %clang_cc1 -O3 -triple x86_64-unknown-linux-gnu -target-cpu x86-64 %s -o %t -dwarf-column-info -opt-record-file %t.yaml -opt-record-passes inline -emit-obj
// RUN: cat %t.yaml | FileCheck -check-prefix=CHECK-PASSES %s
// RUN: not %clang_cc1 -O3 -triple x86_64-unknown-linux-gnu -target-cpu x86-64 %s -o %t -dwarf-column-info -opt-record-file %t.yaml -opt-record-passes "(foo" -emit-obj 2>&1 | FileCheck -check-prefix=CHECK-PATTERN-ERROR %s
// RUN: %clang_cc1 -O3 -triple x86_64-unknown-linux-gnu -target-cpu x86-64 %s -o %t -dwarf-column-info -opt-record-file %t.yaml -opt-record-format yaml -emit-obj
// RUN: cat %t.yaml | FileCheck %s
// RUN: not %clang_cc1 -O3 -triple x86_64-unknown-linux-gnu -target-cpu x86-64 %s -o %t -dwarf-column-info -opt-record-file %t.yaml -opt-record-format "unknown-format" -emit-obj 2>&1 | FileCheck -check-prefix=CHECK-FORMAT-ERROR %s
// REQUIRES: x86-registered-target
void bar();
@ -37,3 +40,5 @@ void Test(int *res, int *c, int *d, int *p, int n) {
// CHECK-PASSES-NOT: loop-vectorize
// CHECK-PATTERN-ERROR: error: in pattern '(foo': parentheses not balanced
// CHECK-FORMAT-ERROR: error: unknown remark serializer format: 'unknown-format'

4
clang/test/Driver/darwin-ld.c
View File

@ -330,6 +330,10 @@
// RUN: %clang -target x86_64-apple-darwin12 %t.o -fsave-optimization-record -foptimization-record-passes=inline -### -o foo/bar.out 2> %t.log
// RUN: FileCheck -check-prefix=PASS_REMARKS_WITH_PASSES %s < %t.log
// PASS_REMARKS_WITH_PASSES: "-mllvm" "-lto-pass-remarks-output" "-mllvm" "foo/bar.out.opt.yaml" "-mllvm" "-lto-pass-remarks-filter=inline"
//
// RUN: %clang -target x86_64-apple-darwin12 %t.o -fsave-optimization-record=some-format -### -o foo/bar.out 2> %t.log
// RUN: FileCheck -check-prefix=PASS_REMARKS_WITH_FORMAT %s < %t.log
// PASS_REMARKS_WITH_FORMAT: "-mllvm" "-lto-pass-remarks-output" "-mllvm" "foo/bar.out.opt.yaml" "-mllvm" "-lto-pass-remarks-format=some-format"
// RUN: %clang -target x86_64-apple-ios6.0 -miphoneos-version-min=6.0 -fprofile-instr-generate -### %t.o 2> %t.log
// RUN: FileCheck -check-prefix=LINK_PROFILE_FIRST %s < %t.log

8
clang/test/Driver/opt-record.c
View File

@ -15,6 +15,9 @@
// RUN: %clang -### -S -o FOO -fsave-optimization-record -foptimization-record-passes=inline %s 2>&1 | FileCheck %s -check-prefix=CHECK-EQ-PASSES
// RUN: %clang -### -S -o FOO -foptimization-record-passes=inline %s 2>&1 | FileCheck %s -check-prefix=CHECK-EQ-PASSES
// RUN: %clang -### -S -o FOO -foptimization-record-passes=inline -fno-save-optimization-record %s 2>&1 | FileCheck %s --check-prefix=CHECK-FOPT-DISABLE-PASSES
// RUN: %clang -### -S -o FOO -fsave-optimization-record -fsave-optimization-record=some-format %s 2>&1 | FileCheck %s -check-prefix=CHECK-EQ-FORMAT
// RUN: %clang -### -S -o FOO -fsave-optimization-record=some-format %s 2>&1 | FileCheck %s -check-prefix=CHECK-EQ-FORMAT
// RUN: %clang -### -S -o FOO -fsave-optimization-record=some-format -fno-save-optimization-record %s 2>&1 | FileCheck %s --check-prefix=CHECK-FOPT-DISABLE-FORMAT
//
// CHECK: "-cc1"
// CHECK: "-opt-record-file" "FOO.opt.yaml"
@ -32,3 +35,8 @@
// CHECK-EQ-PASSES: "-opt-record-passes" "inline"
// CHECK-FOPT-DISABLE-PASSES-NOT: "-fno-save-optimization-record"
// CHECK-EQ-FORMAT: "-cc1"
// CHECK-EQ-FORMAT: "-opt-record-format" "some-format"
// CHECK-FOPT-DISABLE-FORMAT-NOT: "-fno-save-optimization-record"

1
lld/ELF/Config.h
View File

@ -100,6 +100,7 @@ struct Configuration {
llvm::StringRef OutputFile;
llvm::StringRef OptRemarksFilename;
llvm::StringRef OptRemarksPasses;
llvm::StringRef OptRemarksFormat;
llvm::StringRef ProgName;
llvm::StringRef PrintSymbolOrder;
llvm::StringRef SoName;

1
lld/ELF/Driver.cpp
View File

@ -857,6 +857,7 @@ static void readConfigs(opt::InputArgList &Args) {
Config->OptRemarksFilename = Args.getLastArgValue(OPT_opt_remarks_filename);
Config->OptRemarksPasses = Args.getLastArgValue(OPT_opt_remarks_passes);
Config->OptRemarksWithHotness = Args.hasArg(OPT_opt_remarks_with_hotness);
Config->OptRemarksFormat = Args.getLastArgValue(OPT_opt_remarks_format);
Config->Optimize = args::getInteger(Args, OPT_O, 1);
Config->OrphanHandling = getOrphanHandling(Args);
Config->OutputFile = Args.getLastArgValue(OPT_o);

1
lld/ELF/LTO.cpp
View File

@ -99,6 +99,7 @@ static lto::Config createConfig() {
C.RemarksFilename = Config->OptRemarksFilename;
C.RemarksPasses = Config->OptRemarksPasses;
C.RemarksWithHotness = Config->OptRemarksWithHotness;
C.RemarksFormat = Config->OptRemarksFormat;
C.SampleProfile = Config->LTOSampleProfile;
C.UseNewPM = Config->LTONewPassManager;

2
lld/ELF/Options.td
View File

@ -485,6 +485,8 @@ def opt_remarks_passes: Separate<["--"], "opt-remarks-passes">,
HelpText<"Regex for the passes that need to be serialized to the output file">;
def opt_remarks_with_hotness: Flag<["--"], "opt-remarks-with-hotness">,
HelpText<"Include hotness information in the optimization remarks file">;
def opt_remarks_format: Separate<["--"], "opt-remarks-format">,
HelpText<"The format used for serializing remarks (default: YAML)">;
defm plugin_opt: Eq<"plugin-opt", "specifies LTO options for compatibility with GNU linkers">;
def save_temps: F<"save-temps">;
def thinlto_cache_dir: J<"thinlto-cache-dir=">,

3
lld/test/ELF/lto/opt-remarks.ll
View File

@ -11,6 +11,9 @@
; RUN: ld.lld --opt-remarks-filename %t1.yaml --opt-remarks-passes inline %t.o \
; RUN: -o /dev/null -shared
; RUN: cat %t1.yaml | FileCheck %s -check-prefix=YAML-PASSES
; RUN: ld.lld --opt-remarks-filename %t1.yaml --opt-remarks-format yaml %t.o \
; RUN: -o /dev/null -shared
; RUN: cat %t.yaml | FileCheck %s -check-prefix=YAML
; Check that @tinkywinky is inlined after optimizations.
; CHECK-LABEL: define i32 @main

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

@ -85,10 +85,20 @@ struct RemarkSetupPatternError : RemarkSetupErrorInfo<RemarkSetupPatternError> {
using RemarkSetupErrorInfo<RemarkSetupPatternError>::RemarkSetupErrorInfo;
};
struct RemarkSetupFormatError : RemarkSetupErrorInfo<RemarkSetupFormatError> {
static char ID;
using RemarkSetupErrorInfo<RemarkSetupFormatError>::RemarkSetupErrorInfo;
};
enum class RemarksSerializerFormat { Unknown, YAML };
Expected<RemarksSerializerFormat> parseSerializerFormat(StringRef Format);
/// Setup optimization remarks.
Expected<std::unique_ptr<ToolOutputFile>>
setupOptimizationRemarks(LLVMContext &Context, StringRef RemarksFilename,
StringRef RemarksPasses, bool RemarksWithHotness,
StringRef RemarksPasses, StringRef RemarksFormat,
bool RemarksWithHotness,
unsigned RemarksHotnessThreshold = 0);
} // end namespace llvm

3
llvm/include/llvm/LTO/Config.h
View File

@ -108,6 +108,9 @@ struct Config {
/// Whether to emit optimization remarks with hotness informations.
bool RemarksWithHotness = false;
/// The format used for serializing remarks (default: YAML).
std::string RemarksFormat = "";
/// Whether to emit the pass manager debuggging informations.
bool DebugPassManager = false;

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

@ -20,6 +20,7 @@
#include "llvm/ADT/StringSet.h"
#include "llvm/IR/DiagnosticInfo.h"
#include "llvm/IR/ModuleSummaryIndex.h"
#include "llvm/IR/RemarkStreamer.h"
#include "llvm/LTO/Config.h"
#include "llvm/Linker/IRMover.h"
#include "llvm/Object/IRSymtab.h"
@ -85,8 +86,8 @@ std::string getThinLTOOutputFile(const std::string &Path,
/// Setup optimization remarks.
Expected<std::unique_ptr<ToolOutputFile>>
setupOptimizationRemarks(LLVMContext &Context, StringRef RemarksFilename,
StringRef RemarksPasses, bool RemarksWithHotness,
int Count = -1);
StringRef RemarksPasses, StringRef RemarksFormat,
bool RemarksWithHotness, int Count = -1);
/// Setups the output file for saving statistics.
Expected<std::unique_ptr<ToolOutputFile>>

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

@ -109,10 +109,37 @@ void RemarkStreamer::emit(const DiagnosticInfoOptimizationBase &Diag) {
char RemarkSetupFileError::ID = 0;
char RemarkSetupPatternError::ID = 0;
char RemarkSetupFormatError::ID = 0;
static std::unique_ptr<remarks::Serializer>
formatToSerializer(RemarksSerializerFormat RemarksFormat, raw_ostream &OS) {
switch (RemarksFormat) {
default:
llvm_unreachable("Unknown remark serializer format.");
return nullptr;
case RemarksSerializerFormat::YAML:
return llvm::make_unique<remarks::YAMLSerializer>(OS);
};
}
Expected<RemarksSerializerFormat>
llvm::parseSerializerFormat(StringRef StrFormat) {
auto Format = StringSwitch<RemarksSerializerFormat>(StrFormat)
.Cases("", "yaml", RemarksSerializerFormat::YAML)
.Default(RemarksSerializerFormat::Unknown);
if (Format == RemarksSerializerFormat::Unknown)
return createStringError(std::make_error_code(std::errc::invalid_argument),
"Unknown remark serializer format: '%s'",
StrFormat.data());
return Format;
}
Expected<std::unique_ptr<ToolOutputFile>>
llvm::setupOptimizationRemarks(LLVMContext &Context, StringRef RemarksFilename,
StringRef RemarksPasses, bool RemarksWithHotness,
StringRef RemarksPasses, StringRef RemarksFormat,
bool RemarksWithHotness,
unsigned RemarksHotnessThreshold) {
if (RemarksWithHotness)
Context.setDiagnosticsHotnessRequested(true);
@ -131,9 +158,13 @@ llvm::setupOptimizationRemarks(LLVMContext &Context, StringRef RemarksFilename,
if (EC)
return make_error<RemarkSetupFileError>(errorCodeToError(EC));
Expected<RemarksSerializerFormat> Format =
parseSerializerFormat(RemarksFormat);
if (Error E = Format.takeError())
return make_error<RemarkSetupFormatError>(std::move(E));
Context.setRemarkStreamer(llvm::make_unique<RemarkStreamer>(
RemarksFilename,
llvm::make_unique<remarks::YAMLSerializer>(RemarksFile->os())));
RemarksFilename, formatToSerializer(*Format, RemarksFile->os())));
if (!RemarksPasses.empty())
if (Error E = Context.getRemarkStreamer()->setFilter(RemarksPasses))

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

@ -1339,14 +1339,14 @@ Error LTO::runThinLTO(AddStreamFn AddStream, NativeObjectCache Cache,
Expected<std::unique_ptr<ToolOutputFile>>
lto::setupOptimizationRemarks(LLVMContext &Context, StringRef RemarksFilename,
StringRef RemarksPasses, bool RemarksWithHotness,
int Count) {
StringRef RemarksPasses, StringRef RemarksFormat,
bool RemarksWithHotness, int Count) {
std::string Filename = RemarksFilename;
if (!Filename.empty() && Count != -1)
Filename += ".thin." + llvm::utostr(Count) + ".yaml";
auto ResultOrErr = llvm::setupOptimizationRemarks(
Context, Filename, RemarksPasses, RemarksWithHotness);
Context, Filename, RemarksPasses, RemarksFormat, RemarksWithHotness);
if (Error E = ResultOrErr.takeError())
return std::move(E);

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

@ -431,9 +431,9 @@ Error lto::backend(Config &C, AddStreamFn AddStream,
std::unique_ptr<TargetMachine> TM = createTargetMachine(C, *TOrErr, *Mod);
// Setup optimization remarks.
auto DiagFileOrErr =
lto::setupOptimizationRemarks(Mod->getContext(), C.RemarksFilename,
C.RemarksPasses, C.RemarksWithHotness);
auto DiagFileOrErr = lto::setupOptimizationRemarks(
Mod->getContext(), C.RemarksFilename, C.RemarksPasses, C.RemarksFormat,
C.RemarksWithHotness);
if (!DiagFileOrErr)
return DiagFileOrErr.takeError();
auto DiagnosticOutputFile = std::move(*DiagFileOrErr);
@ -488,7 +488,7 @@ Error lto::thinBackend(Config &Conf, unsigned Task, AddStreamFn AddStream,
// Setup optimization remarks.
auto DiagFileOrErr = lto::setupOptimizationRemarks(
Mod.getContext(), Conf.RemarksFilename, Conf.RemarksPasses,
Conf.RemarksWithHotness, Task);
Conf.RemarksFormat, Conf.RemarksWithHotness, Task);
if (!DiagFileOrErr)
return DiagFileOrErr.takeError();
auto DiagnosticOutputFile = std::move(*DiagFileOrErr);

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

@ -97,6 +97,11 @@ cl::opt<std::string>
"names match the given regular expression"),
cl::value_desc("regex"));
cl::opt<std::string> RemarksFormat(
"lto-pass-remarks-format",
cl::desc("The format used for serializing remarks (default: YAML)"),
cl::value_desc("format"), cl::init("yaml"));
cl::opt<std::string> LTOStatsFile(
"lto-stats-file",
cl::desc("Save statistics to the specified file"),
@ -517,8 +522,9 @@ bool LTOCodeGenerator::optimize(bool DisableVerify, bool DisableInline,
if (!this->determineTarget())
return false;
auto DiagFileOrErr = lto::setupOptimizationRemarks(
Context, RemarksFilename, RemarksPasses, RemarksWithHotness);
auto DiagFileOrErr =
lto::setupOptimizationRemarks(Context, RemarksFilename, RemarksPasses,
RemarksFormat, RemarksWithHotness);
if (!DiagFileOrErr) {
errs() << "Error: " << toString(DiagFileOrErr.takeError()) << "\n";
report_fatal_error("Can't get an output file for the remarks");

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

@ -73,6 +73,7 @@ extern cl::opt<bool> LTODiscardValueNames;
extern cl::opt<std::string> RemarksFilename;
extern cl::opt<std::string> RemarksPasses;
extern cl::opt<bool> RemarksWithHotness;
extern cl::opt<std::string> RemarksFormat;
}
namespace {
@ -1020,7 +1021,7 @@ void ThinLTOCodeGenerator::run() {
Context.setDiscardValueNames(LTODiscardValueNames);
Context.enableDebugTypeODRUniquing();
auto DiagFileOrErr = lto::setupOptimizationRemarks(
Context, RemarksFilename, RemarksPasses,
Context, RemarksFilename, RemarksPasses, RemarksFormat,
RemarksWithHotness, count);
if (!DiagFileOrErr) {
errs() << "Error: " << toString(DiagFileOrErr.takeError()) << "\n";

1
llvm/test/ThinLTO/X86/diagnostic-handler-remarks.ll
View File

@ -6,6 +6,7 @@
; RUN: llvm-lto -thinlto-action=run \
; RUN: -lto-pass-remarks-output=%t.yaml \
; RUN: -lto-pass-remarks-filter=inline \
; RUN: -lto-pass-remarks-format=yaml \
; RUN: -exported-symbol _func2 \
; RUN: -exported-symbol _main %t1.bc %t2.bc 2>&1 | \
; RUN: FileCheck %s -allow-empty

2
llvm/test/tools/gold/X86/opt-remarks.ll
View File

@ -3,10 +3,12 @@
; RUN: %gold -m elf_x86_64 -plugin %llvmshlibdir/LLVMgold%shlibext -shared \
; RUN: -plugin-opt=save-temps \
; RUN: -plugin-opt=opt-remarks-passes=inline \
; RUN: -plugin-opt=opt-remarks-format=yaml \
; RUN: -plugin-opt=opt-remarks-filename=%t.yaml %t.o -o %t2.o 2>&1
; RUN: llvm-dis %t2.o.0.4.opt.bc -o - | FileCheck %s
; RUN: %gold -m elf_x86_64 -plugin %llvmshlibdir/LLVMgold%shlibext -shared \
; RUN: -plugin-opt=opt-remarks-passes=inline \
; RUN: -plugin-opt=opt-remarks-format=yaml \
; RUN: -plugin-opt=opt-remarks-with-hotness \
; RUN: -plugin-opt=opt-remarks-filename=%t.hot.yaml %t.o -o %t2.o 2>&1
; RUN: cat %t.yaml | FileCheck %s -check-prefix=YAML

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

@ -209,6 +209,7 @@ namespace options {
static std::string RemarksFilename;
static std::string RemarksPasses;
static bool RemarksWithHotness = false;
static std::string RemarksFormat;
// Context sensitive PGO options.
static std::string cs_profile_path;
@ -290,6 +291,8 @@ namespace options {
RemarksPasses = opt.substr(strlen("opt-remarks-passes="));
} else if (opt == "opt-remarks-with-hotness") {
RemarksWithHotness = true;
} else if (opt.startswith("opt-remarks-format=")) {
RemarksFormat = opt.substr(strlen("opt-remarks-format="));
} else if (opt.startswith("stats-file=")) {
stats_file = opt.substr(strlen("stats-file="));
} else {
@ -913,6 +916,7 @@ static std::unique_ptr<LTO> createLTO(IndexWriteCallback OnIndexWrite,
Conf.RemarksFilename = options::RemarksFilename;
Conf.RemarksPasses = options::RemarksPasses;
Conf.RemarksWithHotness = options::RemarksWithHotness;
Conf.RemarksFormat = options::RemarksFormat;
// Use new pass manager if set in driver
Conf.UseNewPM = options::new_pass_manager;

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

@ -155,6 +155,11 @@ static cl::opt<std::string>
"names match the given regular expression"),
cl::value_desc("regex"));
static cl::opt<std::string> RemarksFormat(
"pass-remarks-format",
cl::desc("The format used for serializing remarks (default: YAML)"),
cl::value_desc("format"), cl::init("yaml"));
namespace {
static ManagedStatic<std::vector<std::string>> RunPassNames;
@ -329,7 +334,8 @@ int main(int argc, char **argv) {
Expected<std::unique_ptr<ToolOutputFile>> RemarksFileOrErr =
setupOptimizationRemarks(Context, RemarksFilename, RemarksPasses,
RemarksWithHotness, RemarksHotnessThreshold);
RemarksFormat, RemarksWithHotness,
RemarksHotnessThreshold);
if (Error E = RemarksFileOrErr.takeError()) {
WithColor::error(errs(), argv[0]) << toString(std::move(E)) << '\n';
return 1;

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

@ -107,6 +107,11 @@ static cl::opt<std::string>
"names match the given regular expression"),
cl::value_desc("regex"));
static cl::opt<std::string> RemarksFormat(
"pass-remarks-format",
cl::desc("The format used for serializing remarks (default: YAML)"),
cl::value_desc("format"), cl::init("yaml"));
static cl::opt<std::string>
SamplePGOFile("lto-sample-profile-file",
cl::desc("Specify a SamplePGO profile file"));
@ -229,6 +234,7 @@ static int run(int argc, char **argv) {
Conf.RemarksFilename = RemarksFilename;
Conf.RemarksPasses = RemarksPasses;
Conf.RemarksWithHotness = RemarksWithHotness;
Conf.RemarksFormat = RemarksFormat;
Conf.SampleProfile = SamplePGOFile;
Conf.CSIRProfile = CSPGOFile;

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

@ -273,6 +273,11 @@ static cl::opt<std::string>
"names match the given regular expression"),
cl::value_desc("regex"));
static cl::opt<std::string> RemarksFormat(
"pass-remarks-format",
cl::desc("The format used for serializing remarks (default: YAML)"),
cl::value_desc("format"), cl::init("yaml"));
cl::opt<PGOKind>
PGOKindFlag("pgo-kind", cl::init(NoPGO), cl::Hidden,
cl::desc("The kind of profile guided optimization"),
@ -552,7 +557,8 @@ int main(int argc, char **argv) {
Expected<std::unique_ptr<ToolOutputFile>> RemarksFileOrErr =
setupOptimizationRemarks(Context, RemarksFilename, RemarksPasses,
RemarksWithHotness, RemarksHotnessThreshold);
RemarksFormat, RemarksWithHotness,
RemarksHotnessThreshold);
if (Error E = RemarksFileOrErr.takeError()) {
errs() << toString(std::move(E)) << '\n';
return 1;