Add support for optimization reports.

[dnovillo]

Summary

This patch adds a new flag -Rpass=. The flag indicates the name
of the optimization pass that should emit remarks stating when it
made a transformation to the code.

This implements the design I proposed in:

https://docs.google.com/document/d/1FYUatSjZZO-zmFBxjOiuOzAy9mhHA8hqdvklZv68WuQ/edit?usp=sharing

[echristo]

Couple of comments here:

a) The WRPass thing is awkward. No, I don't know how to fix it offhand.

The rest are inline.

-eric

lib/CodeGen/CodeGenAction.cpp

390

I'm not sure we can get back to the same encoding, but it could be useful if we wanted to map accordingly.

Also did you want the discriminator here?

lib/Driver/Tools.cpp

3418

Extra braces?

lib/Frontend/CompilerInvocation.cpp

536

I think this will just set line tables only as opposed to the greater of line-tables-only and whatever we've currently got.

[dnovillo]

• Tolerate lack of debug information.

When emitting an optimization report diagnostic, the lack of debug
information sometimes causes internal failures. If debug information
is not present, the diagnostic uses "<unknown>:0:0" as the location
string.

[rsmith]

include/clang/Basic/DiagnosticGroups.td

668

Do you intend for this to be controlled by -WRpass? I don't think you should add a DiagGroup for this one at all.

include/clang/Driver/Options.td

257–260

Should we have a -Rno-pass=... too?

lib/CodeGen/CodeGenAction.cpp

387–389

Maybe add a DefaultRemark to Diagnostic.td, and then add DefaultRemark to the def for your Remark to enable it by default, and drop this?

393–396

Yuck. :( It's not correct to rely on diagnostics being formatted this way: we support several output formats that don't use the 'file:line:col: ' formatting.

Could we annotate the raw form of Clang's SourceLocation onto the IR so that we can use it here? Failing that, you can map the filename/line/column back to a SourceLocation by asking the clang::SourceManager nicely (see SourceManager::translateFileLineCol and FileManager::getFile).

397–399

I think this'll report the wrong warning flag, something like:

remark: something happened [-WRpass]

Ideally we should report

remark: something happened [-Rpass=passname]

You'll probably need to add an optional warning flag name override to DiagnosticsEngine to support this (and use it as an override in printDiagnosticOptions in TextDiagnosticPrinter.cpp).

[qcolombet]

Hi Diego,

I prefer not to comment on the front-end part, I do not know it well enough. I think Richard and Eric's comments do the trick :).

For the diagnostic handler, the way we handle it seems a bit odd. See my inline comment.

Thanks,
-Quentin

lib/CodeGen/CodeGenAction.cpp

441

This does not follow the same pattern as the previous handler, i.e., with the fall through setting the DiagID to use the default handler (the ComputeDiagID part etc.).

My guess is we want to push the check of CodeGenOpts.OptimizationReportPattern into OptimizationReportHandler and check the return of that.

If we do not want to follow the same pattern, we should comment on that. Indeed, I think it is important to explain why we are not reporting anything when CodeGenOpts.OptimizationReportPattern is not set.

[dnovillo]

Address review feedback

• When emitting an optimization report diagnostic, the lack of debug information sometimes causes internal failures. If debug information is not present, the diagnostic uses "<unknown>:0:0" as the location string.
• Rename OptimizationReport to OptimizationRemark.
• Only enable line table generation if no debug information had been requested.
• Add a default remark diagnostic class to enable -Rpass diagnostics.
• Change the diagnostic group for BackendOptimizationRemark to "pass".
• Add DiagnosticIDs::isRemark(). Use it in printDiagnosticOptions to print "-R" instead of "-W" in the diagnostic message.
• Re-word the help text for -Rpass=.
• In BackendConsumer::OptimizationRemarkHandler, get a SourceLocation object out of the file name, line and column number. Use that location in the call to Diags.Report().
• If -Rpass= is used, also enable column information by adding -dwarf-column-info to the backend command line.
• Add test for -Rpass=. Document OptimizationRemarkHandler.

[dnovillo]

• Rename optimization report as optimization remark.

[rsmith]

Looks mostly fine. I'm concerned about a -R option affecting the debug info that ends up in the object file. I'm also concerned that the diagnostic quality will degrade if you build with no debug info enabled at all.

It seems to me that if we can afford the IR size increase from -dwarf-column-info, we can afford the IR size increase from storing the frontend's notion of 'source location' into the IR, and that would allow us to do the right thing without -g and to deal properly with macro expansions etc. (It's only 32 bits per location...)

lib/Driver/Tools.cpp

3422

I don't think it's OK for a diagnostic option to affect the contents of the object file.

lib/Frontend/CompilerInvocation.cpp

523

... so we take the last -Rpass= option, rather than combining them? I find that unintuitive, FWIW, but maybe this is the right model.

[qcolombet]

Hi Diego,

For the part I can comment on (OptimizationRemarkHandler), this LGTM.
For the rest, I leave to Richard the final OK.

Thanks,
Quentin

[dnovillo]

In this update:

• Do not force line/column info generation. Rather, warn when -Rpass is used without debug info.

• Fix BackendConsumer::OptimizationRemarkHandler to operate the same way as the other diagnostic handlers. If no debug information is available, use an empty SourceLocation object.

• Fix the -Rpass test to make it independent of the optimization level used.

[rsmith]

include/clang/Basic/DiagnosticDriverKinds.td

119–121

I think this would make more sense as a note on the diagnostic we produce, if we ever actually produce one.

include/clang/Basic/DiagnosticFrontendKinds.td

35–42

I assume that these shouldn't all be Remarks?

Notes should not have an InGroup.

Please put a space to the left of the : (this file is inconsistent on this, but spaces on both sides is the established convention elsewhere).

Are you actually using any of these except for the remark_... form?

include/clang/Driver/Options.td

259

No full stop here, please. (I think we're inconsistent on this too.)

lib/Frontend/CompilerInvocation.cpp

526

It looks like this is leaked. Maybe use an llvm::Optional<llvm::Regex> instead?

[dnovillo]

include/clang/Basic/DiagnosticDriverKinds.td

119–121

Oh, yeah, much better. Done. One question, however, this will cause the note to be emitted on every remark we print. Should I try to reduce the noise by making sure it's only emitted once?

include/clang/Basic/DiagnosticFrontendKinds.td

35–42

I fixed them to be the right type. They are not really used, except by the boilerplate macro ComputeDiagRemarkID() in lib/CodeGen/CodeGenAction.cpp. I replicated the behaviour of all the other handlers. I am not really sure what they are supposed to do.

include/clang/Driver/Options.td

259

Done.

lib/Frontend/CompilerInvocation.cpp

526

I tried but llvm::Regex has an explicitly deleted constructor. I'm not sure how to deal with that, so I ended up using regular pointer semantics.

[dnovillo]

Address review feedback.

[rsmith]

include/clang/Basic/DiagnosticFrontendKinds.td

40–42

Maybe better phrased as:

"use -gline-tables-only -gcolumn-info to track source location information for this optimization remark"

lib/CodeGen/CodeGenAction.cpp

441

It looks like we get here (and potentially use the error/warning forms of the remark diagnostic) if the diagnostic severity isn't DS_Remark. I don't think this is what we want -- maybe the severity check in OptimizationRemarkHandler should be an assert?

lib/Frontend/CompilerInvocation.cpp

526

llvm::Optional shouldn't call the llvm::Regex default constructor.

[dnovillo]

include/clang/Basic/DiagnosticFrontendKinds.td

40–42

Done.

lib/CodeGen/CodeGenAction.cpp

441

OK. This takes me back to my previous version, where I would not try to handle anything other than remarks. This means that the other codes I was forced to add can disappear.

lib/Frontend/CompilerInvocation.cpp

526

Sure, but it's trying to when instantiating CodeGenOptions:

llvm/include/llvm/ADT/Optional.h:39:28: error: call to deleted constructor of 'llvm::Regex'

new (storage.buffer) T(*O);
                     ^ ~~

llvm/tools/clang/include/clang/Frontend/CodeGenOptions.h:39:7: note: in instantiation of member function 'llvm::Optional<llvm::Regex>::Optional' requested here
class CodeGenOptions : public CodeGenOptionsBase {

^

llvm/include/llvm/Support/Regex.h:49:5: note: 'Regex' has been explicitly marked deleted here

Regex(const Regex &) LLVM_DELETED_FUNCTION;
^

1 error generated.

I'm not quite sure how to deal with this. All I'm doing is:

• llvm::Regex *OptimizationRemarkPattern;

+ llvm::Optional<llvm::Regex> OptimizationRemarkPattern;

I feel like I'm missing something.

[dnovillo]

Address review feedback.

[rsmith]

LGTM with a fix for the memory leak.

lib/Frontend/CompilerInvocation.cpp

526

Oh, I see. What this crummy diagnostic is trying to tell you is that Regex isn't copyable, but someone is trying to make a copy of the CodeGenOptions object somewhere (we don't actually say where, due to an interaction of recursive special member generation and delayed function template instantiation...). CodeGeneratorImpl::CodeGenOpts does this, there might be other places.

Next idea: use std::shared_ptr<llvm::Regex>.

[dnovillo]

• Change OptimizationRemarkPattern into a shared_ptr to avoid memory leaks.

include/clang/Basic/Diagnostic.td

 class DefaultError  { DiagMapping DefaultMapping = MAP_ERROR; }
 class DefaultFatal  { DiagMapping DefaultMapping = MAP_FATAL; }
 class DefaultWarnNoWerror {
   bit WarningNoWerror = 1;
 }
 class DefaultWarnShowInSystemHeader {
   bit WarningShowInSystemHeader = 1;
 }
+class DefaultRemark { DiagMapping DefaultMapping = MAP_REMARK; }
 
 // Definitions for Diagnostics.
 include "DiagnosticASTKinds.td"
 include "DiagnosticAnalysisKinds.td"
 include "DiagnosticCommentKinds.td"
 include "DiagnosticCommonKinds.td"
 include "DiagnosticDriverKinds.td"
 include "DiagnosticFrontendKinds.td"
 include "DiagnosticLexKinds.td"
 include "DiagnosticParseKinds.td"
 include "DiagnosticSemaKinds.td"
 include "DiagnosticSerializationKinds.td"
 

include/clang/Basic/DiagnosticDriverKinds.td

 def err_arc_unsupported_on_toolchain : Error< // feel free to generalize this
   "-fobjc-arc is not supported on versions of OS X prior to 10.6">;
 def err_drv_mg_requires_m_or_mm : Error<
   "option '-MG' requires '-M' or '-MM'">;
 def err_drv_unknown_objc_runtime : Error<
   "unknown or ill-formed Objective-C runtime '%0'">;
 def err_drv_emit_llvm_link : Error<
    "-emit-llvm cannot be used when linking">;
+def err_drv_optimization_remark_pattern : Error<
+  "%0 in '%1'">;
 
 def warn_O4_is_O3 : Warning<"-O4 is equivalent to -O3">, InGroup<Deprecated>;
 def warn_drv_optimization_value : Warning<"optimization level '%0' is unsupported; using '%1%2' instead">,
   InGroup<InvalidCommandLineArgument>;
 def warn_c_kext : Warning<
   "ignoring -fapple-kext which is valid for C++ and Objective-C++ only">;
 def warn_drv_input_file_unused : Warning<
   "%0: '%1' input unused%select{ when '%3' is present|}2">,
   InGroup<UnusedCommandLineArgument>;
 def warn_drv_input_file_unused_by_cpp : Warning<
   "%0: '%1' input unused in cpp mode">,

include/clang/Basic/DiagnosticFrontendKinds.td

 def err_fe_backend_frame_larger_than: Error<"%0">, CatBackend;
 def note_fe_backend_frame_larger_than: Note<"%0">, CatBackend;
 
 def warn_fe_backend_plugin: Warning<"%0">, CatBackend, InGroup<BackendPlugin>;
 def err_fe_backend_plugin: Error<"%0">, CatBackend;
 def remark_fe_backend_plugin: Remark<"%0">, CatBackend, InGroup<RemarkBackendPlugin>;
 def note_fe_backend_plugin: Note<"%0">, CatBackend;
 
+def remark_fe_backend_optimization_remark : Remark<"%0">, CatBackend,
+    InGroup<BackendOptimizationRemark>, DefaultRemark;
+def note_fe_backend_optimization_remark_missing_loc : Note<"use "
+  "-gline-tables-only -gcolumn-info to track source location information "
+  "for this optimization remark">;
+
 def err_fe_invalid_code_complete_file : Error<
     "cannot locate code-completion file %0">, DefaultFatal;
 def err_fe_stdout_binary : Error<"unable to change standard output to binary">,
   DefaultFatal;
 def err_fe_dependency_file_requires_MT : Error<
     "-dependency-file requires at least one -MT or -MQ option">;
 def err_fe_invalid_plugin_name : Error<
     "unable to find plugin '%0'">;
 def err_fe_expected_compiler_job : Error<
     "unable to handle compilation, expected exactly one compiler job in '%0'">;

include/clang/Basic/DiagnosticGroups.td

 // OpenMP warnings.
 def SourceUsesOpenMP : DiagGroup<"source-uses-openmp">;
 
 // Backend warnings.
 def BackendInlineAsm : DiagGroup<"inline-asm">;
 def BackendFrameLargerThan : DiagGroup<"frame-larger-than">;
 def BackendPlugin : DiagGroup<"backend-plugin">;
 def RemarkBackendPlugin : DiagGroup<"remark-backend-plugin">;
+def BackendOptimizationRemark : DiagGroup<"pass">;
 
 // Instrumentation based profiling warnings.
 def ProfileInstrOutOfDate : DiagGroup<"profile-instr-out-of-date">;

include/clang/Basic/DiagnosticIDs.h

public:
   /// This only works on builtin diagnostics, not custom ones, and is not
   /// legal to call on NOTEs.
   static bool isBuiltinWarningOrExtension(unsigned DiagID);
 
   /// \brief Return true if the specified diagnostic is mapped to errors by
   /// default.
   static bool isDefaultMappingAsError(unsigned DiagID);
 
+  /// \brief Return true if the specified diagnostic is a Remark.
+  static bool isRemark(unsigned DiagID);
+
   /// \brief Determine whether the given built-in diagnostic ID is a Note.
   static bool isBuiltinNote(unsigned DiagID);
 
   /// \brief Determine whether the given built-in diagnostic ID is for an
   /// extension of some sort.
   static bool isBuiltinExtensionDiag(unsigned DiagID) {
     bool ignored;
     return isBuiltinExtensionDiag(DiagID, ignored);

include/clang/Driver/Options.td

 def CompileOnly_Group     : OptionGroup<"<CompileOnly group>">;
 
 def Action_Group          : OptionGroup<"<action group>">;
 
 def I_Group               : OptionGroup<"<I group>">, Group<CompileOnly_Group>;
 def M_Group               : OptionGroup<"<M group>">, Group<CompileOnly_Group>;
 def T_Group               : OptionGroup<"<T group>">;
 def O_Group               : OptionGroup<"<O group>">, Group<CompileOnly_Group>;
+def R_Group               : OptionGroup<"<R group>">, Group<CompileOnly_Group>;
 def W_Group               : OptionGroup<"<W group>">, Group<CompileOnly_Group>;
 def d_Group               : OptionGroup<"<d group>">;
 def f_Group               : OptionGroup<"<f group>">, Group<CompileOnly_Group>;
 def f_clang_Group         : OptionGroup<"<f (clang-only) group>">, Group<CompileOnly_Group>;
 def g_Group               : OptionGroup<"<g group>">;
 def g_flags_Group         : OptionGroup<"<g flags group>">;
 def i_Group               : OptionGroup<"<i group>">, Group<CompileOnly_Group>;
 def clang_i_Group         : OptionGroup<"<clang i group>">, Group<i_Group>;

 def O_flag : Flag<["-"], "O">, Flags<[CC1Option]>, Alias<O>, AliasArgs<["2"]>;
 def Ofast : Joined<["-"], "Ofast">, Group<O_Group>, Flags<[CC1Option]>;
 def P : Flag<["-"], "P">, Flags<[CC1Option]>,
   HelpText<"Disable linemarker output in -E mode">;
 def Qn : Flag<["-"], "Qn">;
 def Qunused_arguments : Flag<["-"], "Qunused-arguments">, Flags<[DriverOption, CoreOption]>,
   HelpText<"Don't emit warning for unused driver arguments">;
 def Q : Flag<["-"], "Q">;
-def R : Flag<["-"], "R">;
+def Rpass_EQ : Joined<["-"], "Rpass=">, Group<R_Group>, Flags<[CC1Option]>,
+  HelpText<"Report transformations performed by optimization passes whose "
+           "name matches the given POSIX regular expression">;
 def S : Flag<["-"], "S">, Flags<[DriverOption,CC1Option]>, Group<Action_Group>,
   HelpText<"Only run preprocess and compilation steps">;
 def Tbss : JoinedOrSeparate<["-"], "Tbss">, Group<T_Group>;
 def Tdata : JoinedOrSeparate<["-"], "Tdata">, Group<T_Group>;
 def Ttext : JoinedOrSeparate<["-"], "Ttext">, Group<T_Group>;
 def T : JoinedOrSeparate<["-"], "T">, Group<T_Group>;
 def U : JoinedOrSeparate<["-"], "U">, Group<CompileOnly_Group>, Flags<[CC1Option]>;
 def V : JoinedOrSeparate<["-"], "V">, Flags<[DriverOption, Unsupported]>;
 def Wa_COMMA : CommaJoined<["-"], "Wa,">,

include/clang/Frontend/CodeGenOptions.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_FRONTEND_CODEGENOPTIONS_H
 #define LLVM_CLANG_FRONTEND_CODEGENOPTIONS_H
 
 #include <string>
 #include <vector>
+#include "llvm/Support/Regex.h"
 
 namespace clang {
 
 /// \brief Bitfields of CodeGenOptions, split out from CodeGenOptions to ensure
 /// that this large collection of bitfields is a trivial class type.
 class CodeGenOptionsBase {
 public:
 #define CODEGENOPT(Name, Bits, Default) unsigned Name : Bits;
public:
   std::vector<std::string> DependentLibraries;
 
   /// Name of the profile file to use with -fprofile-sample-use.
   std::string SampleProfileFile;
 
   /// Name of the profile file to use as input for -fprofile-instr-use
   std::string InstrProfileInput;
 
+  /// Regular expression to select optimizations for which we should enable
+  /// optimization remarks. Transformation passes whose name matches this
+  /// expression (and support this feature), will emit a diagnostic
+  /// whenever they perform a transformation. This is enabled by the
+  /// -Rpass=regexp flag.
+  std::shared_ptr<llvm::Regex> OptimizationRemarkPattern;
+
 public:
   // Define accessors/mutators for code generation options of enumeration type.
 #define CODEGENOPT(Name, Bits, Default)
 #define ENUM_CODEGENOPT(Name, Type, Bits, Default) \
   Type get##Name() const { return static_cast<Type>(Name); } \
   void set##Name(Type Value) { Name = static_cast<unsigned>(Value); }
 #include "clang/Frontend/CodeGenOptions.def"
 

lib/Basic/DiagnosticIDs.cpp

 
 bool DiagnosticIDs::isDefaultMappingAsError(unsigned DiagID) {
   if (DiagID >= diag::DIAG_UPPER_LIMIT)
     return false;
 
   return GetDefaultDiagMappingInfo(DiagID).getMapping() == diag::MAP_ERROR;
 }
 
+bool DiagnosticIDs::isRemark(unsigned DiagID) {
+  return DiagID < diag::DIAG_UPPER_LIMIT &&
+         getBuiltinDiagClass(DiagID) == CLASS_REMARK;
+}
+
 /// getDescription - Given a diagnostic ID, return a description of the
 /// issue.
 StringRef DiagnosticIDs::getDescription(unsigned DiagID) const {
   if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID))
     return Info->getDescription();
   return CustomDiagInfo->getDescription(DiagID);
 }
 

lib/CodeGen/CodeGenAction.cpp

 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/CodeGen/BackendUtil.h"
 #include "clang/CodeGen/ModuleBuilder.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/FrontendDiagnostic.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Bitcode/ReaderWriter.h"
+#include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/DiagnosticPrinter.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IRReader/IRReader.h"
 #include "llvm/Linker/Linker.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/MemoryBuffer.h"
public:
     /// \brief Specialized handler for InlineAsm diagnostic.
     /// \return True if the diagnostic has been successfully reported, false
     /// otherwise.
     bool InlineAsmDiagHandler(const llvm::DiagnosticInfoInlineAsm &D);
     /// \brief Specialized handler for StackSize diagnostic.
     /// \return True if the diagnostic has been successfully reported, false
     /// otherwise.
     bool StackSizeDiagHandler(const llvm::DiagnosticInfoStackSize &D);
+    /// \brief Specialized handler for the optimization diagnostic.
+    /// Note that this handler only accepts remarks and it always handles
+    /// them.
+    void
+    OptimizationRemarkHandler(const llvm::DiagnosticInfoOptimizationRemark &D);
   };
   
   void BackendConsumer::anchor() {}
 }
 
 /// ConvertBackendLocation - Convert a location in a temporary llvm::SourceMgr
 /// buffer to be a valid FullSourceLoc.
 static FullSourceLoc ConvertBackendLocation(const llvm::SMDiagnostic &D,
BackendConsumer::StackSizeDiagHandler(const llvm::DiagnosticInfoStackSize &D) {
   // FIXME: We should demangle the function name.
   // FIXME: Is there a way to get a location for that function?
   FullSourceLoc Loc;
   Diags.Report(Loc, diag::warn_fe_backend_frame_larger_than)
       << D.getStackSize() << D.getFunction().getName();
   return true;
 }
 
+void BackendConsumer::OptimizationRemarkHandler(
+    const llvm::DiagnosticInfoOptimizationRemark &D) {
+  // We only support remarks.
+  assert (D.getSeverity() == llvm::DS_Remark);
+
+  // Optimization remarks are active only if -Rpass=regexp is given and the
+  // regular expression pattern in 'regexp' matches the name of the pass
+  // name in \p D.
+  if (CodeGenOpts.OptimizationRemarkPattern &&
+      CodeGenOpts.OptimizationRemarkPattern->match(D.getPassName())) {
+    SourceManager &SourceMgr = Context->getSourceManager();
+    FileManager &FileMgr = SourceMgr.getFileManager();
+    StringRef Filename;
+    unsigned Line, Column;
+    D.getLocation(&Filename, &Line, &Column);
+    SourceLocation Loc;
+    if (Line > 0) {
+      // If -gcolumn-info was not used, Column will be 0. This upsets the
+      // source manager, so if Column is not set, set it to 1.
+      if (Column == 0)
+        Column = 1;
+      Loc = SourceMgr.translateFileLineCol(FileMgr.getFile(Filename), Line,
+                                           Column);
+    }
+    Diags.Report(Loc, diag::remark_fe_backend_optimization_remark)
+        << D.getMsg().str();
+
+    if (Line == 0)
+      // If we could not extract a source location for the diagnostic,
+      // inform the user how they can get source locations back.
+      //
+      // FIXME: We should really be generating !srcloc annotations when
+      // -Rpass is used. !srcloc annotations need to be emitted in
+      // approximately the same spots as !dbg nodes.
+      Diags.Report(diag::note_fe_backend_optimization_remark_missing_loc);
+  }
+}
+
 /// \brief This function is invoked when the backend needs
 /// to report something to the user.
 void BackendConsumer::DiagnosticHandlerImpl(const DiagnosticInfo &DI) {
   unsigned DiagID = diag::err_fe_inline_asm;
   llvm::DiagnosticSeverity Severity = DI.getSeverity();
   // Get the diagnostic ID based.
   switch (DI.getKind()) {
   case llvm::DK_InlineAsm:
     if (InlineAsmDiagHandler(cast<DiagnosticInfoInlineAsm>(DI)))
       return;
     ComputeDiagID(Severity, inline_asm, DiagID);
     break;
   case llvm::DK_StackSize:
     if (StackSizeDiagHandler(cast<DiagnosticInfoStackSize>(DI)))
       return;
     ComputeDiagID(Severity, backend_frame_larger_than, DiagID);
     break;
+  case llvm::DK_OptimizationRemark:
+    // Optimization remarks are always handled completely by this
+    // handler. There is no generic way of emitting them.
+    OptimizationRemarkHandler(cast<DiagnosticInfoOptimizationRemark>(DI));
+    return;
   default:
     // Plugin IDs are not bound to any value as they are set dynamically.
     ComputeDiagRemarkID(Severity, backend_plugin, DiagID);
     break;
   }
   std::string MsgStorage;
   {
     raw_string_ostream Stream(MsgStorage);

lib/Driver/Tools.cpp

   if (Arg *A = Args.getLastArg(options::OPT_fprofile_sample_use_EQ)) {
     StringRef fname = A->getValue();
     if (!llvm::sys::fs::exists(fname))
       D.Diag(diag::err_drv_no_such_file) << fname;
     else
       A->render(Args, CmdArgs);
   }
 
+  if (Arg *A = Args.getLastArg(options::OPT_Rpass_EQ))
+    A->render(Args, CmdArgs);
+
   if (Args.hasArg(options::OPT_mkernel)) {
     if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType))
       CmdArgs.push_back("-fapple-kext");
     if (!Args.hasArg(options::OPT_fbuiltin))
       CmdArgs.push_back("-fno-builtin");
     Args.ClaimAllArgs(options::OPT_fno_builtin);
   }
   // -fbuiltin is default.
   else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
     CmdArgs.push_back("-fno-builtin");

lib/Frontend/CompilerInvocation.cpp

if (Arg *A = Args.getLastArg(OPT_fpcc_struct_return, OPT_freg_struct_return)) {
     } else {
       assert(A->getOption().matches(OPT_freg_struct_return));
       Opts.setStructReturnConvention(CodeGenOptions::SRCK_InRegs);
     }
   }
 
   Opts.DependentLibraries = Args.getAllArgValues(OPT_dependent_lib);
 
+  if (Arg *A = Args.getLastArg(OPT_Rpass_EQ)) {
+    StringRef Val = A->getValue();
+    std::string RegexError;
+    Opts.OptimizationRemarkPattern = std::make_shared<llvm::Regex>(Val);
+    if (!Opts.OptimizationRemarkPattern->isValid(RegexError)) {
+      Diags.Report(diag::err_drv_optimization_remark_pattern)
+          << RegexError << A->getAsString(Args);
+      Opts.OptimizationRemarkPattern.reset();
+    }
+  }
+
   return Success;
 }
 
 static void ParseDependencyOutputArgs(DependencyOutputOptions &Opts,
                                       ArgList &Args) {
   using namespace options;
   Opts.OutputFile = Args.getLastArgValue(OPT_dependency_file);
   Opts.Targets = Args.getAllArgValues(OPT_MT);
   Opts.IncludeSystemHeaders = Args.hasArg(OPT_sys_header_deps);
   Opts.IncludeModuleFiles = Args.hasArg(OPT_module_file_deps);
   Opts.UsePhonyTargets = Args.hasArg(OPT_MP);

lib/Frontend/TextDiagnosticPrinter.cpp

if (Level == DiagnosticsEngine::Error &&
         DiagnosticIDs::isBuiltinWarningOrExtension(Info.getID()) &&
         !DiagnosticIDs::isDefaultMappingAsError(Info.getID())) {
       OS << " [-Werror";
       Started = true;
     }
 
     StringRef Opt = DiagnosticIDs::getWarningOptionForDiag(Info.getID());
     if (!Opt.empty()) {
-      OS << (Started ? "," : " [") << "-W" << Opt;
+      OS << (Started ? "," : " [")
+         << (DiagnosticIDs::isRemark(Info.getID()) ? "-R" : "-W") << Opt;
       Started = true;
     }
   }
 
   // If the user wants to see category information, include it too.
   if (DiagOpts.ShowCategories) {
     unsigned DiagCategory =
       DiagnosticIDs::getCategoryNumberForDiag(Info.getID());

test/Frontend/optimization-remark.c

+// This file tests the -Rpass= flag with the inliner. The test is
+// designed to always trigger the inliner, so it should be independent
+// of the optimization level.
+
+// RUN: %clang -c %s -Rpass=inline -O0 -gline-tables-only -o /dev/null 2> %t.err
+// RUN: FileCheck < %t.err %s --check-prefix=INLINE
+
+// RUN: %clang -c %s -Rpass=inline -O0 -o /dev/null 2> %t.err
+// RUN: FileCheck < %t.err %s --check-prefix=INLINE-NO-LOC
+
+int foo(int x, int y) __attribute__((always_inline));
+
+int foo(int x, int y) { return x + y; }
+int bar(int j) { return foo(j, j - 2); }
+
+// INLINE: remark: foo inlined into bar [-Rpass]
+
+// INLINE-NO-LOC: {{^remark: foo inlined into bar}}
+// INLINE-NO-LOC: note: use -gline-tables-only -gcolumn-info to track