Add support for missed and analysis optimization remarks.

[dnovillo]

Summary

This adds two new diagnostics: -pass-remarks-missed and
-pass-remarks-analysis. They take the same values as -pass-remarks but
are intended to be triggered in different contexts.

-pass-remarks-missed is used by LLVMContext::emitOptimizationRemarkMissed,
which passes call when they tried to apply a transformation but
couldn't.

-pass-remarks-analysis is used by LLVMContext::emitOptimizationRemarkAnalysis,
which passes call when they want to inform the user about analysis
results.

The patch also adds support in the inliner for the two new remarks and a
test case.

[dnovillo]

ping?

[qcolombet]

Hi Diego,

This overall LGTM.
I have one concern though.
The LLVMContext begins to have a lot of its API dedicated to diagnostic report. All those helper functions calls LLVMContext::diagnose and I would prefer to have just this specific method (emitError being the exception) than having a profusion of such helpers in that class.
I think it would make sense to have those helper functions in the DiagnosticInfo header. That way it would be better self contained.
This is my 2 cents.

What do you think?

Thanks,
-Quentin

[dnovillo]

• Move emitOptimizationRemark* functions to llvm namespace.

[qcolombet]

Hi Diego,

Thanks for the diff, I was wondering where some of the changes came from :).

This LGTM.

One remark, would it be possible to move the PassRemarkXXX options and related implementation in the DiagnosticInfo implementation too?
I.e., stuff related to static cl::opt<PassRemarksOpt, etc.

If it is possible, you can fix that in a subsequent commit, if it is not I can live with that :).

Thanks,
-Quentin

[dnovillo]

Closed by commit rL209442 (authored by @dnovillo).

include/llvm/IR/DiagnosticInfo.h

 #include "llvm/Support/Casting.h"
 
 namespace llvm {
 
 // Forward declarations.
 class DiagnosticPrinter;
 class Function;
 class Instruction;
+class LLVMContextImpl;
 class Twine;
 class Value;
 class DebugLoc;
 
 /// \brief Defines the different supported severity of a diagnostic.
 enum DiagnosticSeverity {
   DS_Error,
   DS_Warning,
   DS_Remark,
   // A note attaches additional information to one of the previous diagnostic
   // types.
   DS_Note
 };
 
 /// \brief Defines the different supported kind of a diagnostic.
 /// This enum should be extended with a new ID for each added concrete subclass.
 enum DiagnosticKind {
   DK_InlineAsm,
   DK_StackSize,
   DK_DebugMetadataVersion,
   DK_SampleProfile,
   DK_OptimizationRemark,
+  DK_OptimizationRemarkMissed,
+  DK_OptimizationRemarkAnalysis,
   DK_FirstPluginKind
 };
 
 /// \brief Get the next available kind ID for a plugin diagnostic.
 /// Each time this function is called, it returns a different number.
 /// Therefore, a plugin that wants to "identify" its own classes
 /// with a dynamic identifier, just have to use this method to get a new ID
 /// and assign it to each of its classes.
private:
   /// Line number where the diagnostic occurred. If 0, no line number will
   /// be emitted in the message.
   unsigned LineNum;
 
   /// Message to report.
   const Twine &Msg;
 };
 
-/// Diagnostic information for optimization remarks.
-class DiagnosticInfoOptimizationRemark : public DiagnosticInfo {
+/// Common features for diagnostics dealing with optimization remarks.
+class DiagnosticInfoOptimizationRemarkBase : public DiagnosticInfo {
 public:
-  /// \p PassName is the name of the pass emitting this diagnostic. If
-  /// this name matches the regular expression given in -Rpass=, then the
-  /// diagnostic will be emitted. \p Fn is the function where the diagnostic
-  /// is being emitted. \p DLoc is the location information to use in the
-  /// diagnostic. If line table information is available, the diagnostic
-  /// 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
-  /// must be valid for the whole life time of the diagnostic.
-  DiagnosticInfoOptimizationRemark(const char *PassName, const Function &Fn,
+  /// \p PassName is the name of the pass emitting this diagnostic.
+  /// \p Fn is the function where the diagnostic is being emitted. \p DLoc is
+  /// the location information to use in the diagnostic. If line table
+  /// information is available, the diagnostic 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 must be valid for the whole life time
+  /// of the diagnostic.
+  DiagnosticInfoOptimizationRemarkBase(enum DiagnosticKind Kind,
+                                       const char *PassName, const Function &Fn,
                                        const DebugLoc &DLoc, const Twine &Msg)
-      : DiagnosticInfo(DK_OptimizationRemark, DS_Remark), PassName(PassName),
-        Fn(Fn), DLoc(DLoc), Msg(Msg) {}
+      : DiagnosticInfo(Kind, DS_Remark), PassName(PassName), Fn(Fn), DLoc(DLoc),
+        Msg(Msg) {}
 
   /// \see DiagnosticInfo::print.
   void print(DiagnosticPrinter &DP) const override;
 
   /// Hand rolled RTTI.
   static bool classof(const DiagnosticInfo *DI) {
     return DI->getKind() == DK_OptimizationRemark;
   }
 
+  /// Return true if this optimization remark is enabled by one of
+  /// of the LLVM command line flags (-pass-remarks, -pass-remarks-missed,
+  /// or -pass-remarks-analysis). Note that this only handles the LLVM
+  /// flags. We cannot access Clang flags from here (they are handled
+  /// in BackendConsumer::OptimizationRemarkHandler).
+  ///
+  /// \p pImpl points to the current LLVM context. It is needed to query the
+  /// value of the command line flag associated with this remark.
+  virtual bool isEnabled(LLVMContextImpl *pImpl) const = 0;
+
   /// Return true if location information is available for this diagnostic.
   bool isLocationAvailable() const;
 
   /// Return a string with the location information for this diagnostic
   /// in the format "file:line:col". If location information is not available,
   /// it returns "<unknown>:0:0".
   const std::string getLocationStr() const;
 
private:
 
   /// Debug location where this diagnostic is triggered.
   DebugLoc DLoc;
 
   /// Message to report.
   const Twine &Msg;
 };
 
+/// Diagnostic information for applied optimization remarks.
+class DiagnosticInfoOptimizationRemark
+    : public DiagnosticInfoOptimizationRemarkBase {
+public:
+  /// \p PassName is the name of the pass emitting this diagnostic. If
+  /// this name matches the regular expression given in -Rpass=, then the
+  /// diagnostic will be emitted. \p Fn is the function where the diagnostic
+  /// is being emitted. \p DLoc is the location information to use in the
+  /// diagnostic. If line table information is available, the diagnostic
+  /// 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
+  /// must be valid for the whole life time of the diagnostic.
+  DiagnosticInfoOptimizationRemark(const char *PassName, const Function &Fn,
+                                   const DebugLoc &DLoc, const Twine &Msg)
+      : DiagnosticInfoOptimizationRemarkBase(DK_OptimizationRemark, PassName,
+                                             Fn, DLoc, Msg) {}
+
+  /// Hand rolled RTTI
+  static bool classof(const DiagnosticInfo *DI) {
+    return DI->getKind() == DK_OptimizationRemark;
+  }
+
+  /// \see DiagnosticInfoOptimizationRemarkBase::isEnabled.
+  virtual bool isEnabled(LLVMContextImpl *pImpl) const override;
+};
+
+/// Diagnostic information for missed-optimization remarks.
+class DiagnosticInfoOptimizationRemarkMissed
+    : public DiagnosticInfoOptimizationRemarkBase {
+public:
+  /// \p PassName is the name of the pass emitting this diagnostic. If
+  /// this name matches the regular expression given in -Rpass-missed=, then the
+  /// diagnostic will be emitted. \p Fn is the function where the diagnostic
+  /// is being emitted. \p DLoc is the location information to use in the
+  /// diagnostic. If line table information is available, the diagnostic
+  /// 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
+  /// must be valid for the whole life time of the diagnostic.
+  DiagnosticInfoOptimizationRemarkMissed(const char *PassName,
+                                         const Function &Fn,
+                                         const DebugLoc &DLoc, const Twine &Msg)
+      : DiagnosticInfoOptimizationRemarkBase(DK_OptimizationRemarkMissed,
+                                             PassName, Fn, DLoc, Msg) {}
+
+  /// Hand rolled RTTI
+  static bool classof(const DiagnosticInfo *DI) {
+    return DI->getKind() == DK_OptimizationRemarkMissed;
+  }
+
+  /// \see DiagnosticInfoOptimizationRemarkBase::isEnabled.
+  virtual bool isEnabled(LLVMContextImpl *pImpl) const override;
+};
+
+/// Diagnostic information for optimization analysis remarks.
+class DiagnosticInfoOptimizationRemarkAnalysis
+    : public DiagnosticInfoOptimizationRemarkBase {
+public:
+  /// \p PassName is the name of the pass emitting this diagnostic. If
+  /// this name matches the regular expression given in -Rpass-analysis=, then
+  /// the diagnostic will be emitted. \p Fn is the function where the diagnostic
+  /// is being emitted. \p DLoc is the location information to use in the
+  /// diagnostic. If line table information is available, the diagnostic 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 must be valid for
+  /// the whole life time of the diagnostic.
+  DiagnosticInfoOptimizationRemarkAnalysis(const char *PassName,
+                                           const Function &Fn,
+                                           const DebugLoc &DLoc,
+                                           const Twine &Msg)
+      : DiagnosticInfoOptimizationRemarkBase(DK_OptimizationRemarkAnalysis,
+                                             PassName, Fn, DLoc, Msg) {}
+
+  /// Hand rolled RTTI
+  static bool classof(const DiagnosticInfo *DI) {
+    return DI->getKind() == DK_OptimizationRemarkAnalysis;
+  }
+
+  /// \see DiagnosticInfoOptimizationRemarkBase::isEnabled.
+  virtual bool isEnabled(LLVMContextImpl *pImpl) const override;
+};
+
 // Create wrappers for C Binding types (see CBindingWrapping.h).
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(DiagnosticInfo, LLVMDiagnosticInfoRef)
 
 } // End namespace llvm
 
 #endif

include/llvm/IR/LLVMContext.h

public:
   /// with optional location information.  This function returns, so code should
   /// be prepared to drop the erroneous construct on the floor and "not crash".
   /// The generated code need not be correct.  The error message will be
   /// implicitly prefixed with "error: " and should not end with a ".".
   void emitError(unsigned LocCookie, const Twine &ErrorStr);
   void emitError(const Instruction *I, const Twine &ErrorStr);
   void emitError(const Twine &ErrorStr);
 
-  /// emitOptimizationRemark - Emit an optimization remark message. \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 DLoc is the debug location where the diagnostic is generated.
-  /// \p Msg is the message string to use.
+  /// Emit an optimization-applied message. \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 DLoc is the debug location where
+  /// the diagnostic is generated. \p Msg is the message string to use.
   void emitOptimizationRemark(const char *PassName, const Function &Fn,
                               const DebugLoc &DLoc, const Twine &Msg);
 
+  /// Emit an optimization-missed message. \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 DLoc is the
+  /// debug location where the diagnostic is generated. \p Msg is the
+  /// message string to use.
+  void emitOptimizationRemarkMissed(const char *PassName, const Function &Fn,
+                                    const DebugLoc &DLoc, const Twine &Msg);
+
+  /// Emit an optimization analysis remark message. \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 DLoc is the debug
+  /// location where the diagnostic is generated. \p Msg is the message string
+  /// to use.
+  void emitOptimizationRemarkAnalysis(const char *PassName, const Function &Fn,
+                                      const DebugLoc &DLoc, const Twine &Msg);
+
   /// \brief Notify that we finished running a pass.
   void notifyPassRun(Pass *P, Module *M, Function *F = nullptr,
                      BasicBlock *BB = nullptr);
   /// \brief Register the given PassRunListener to receive notifyPassRun()
   /// callbacks whenever a pass ran. The context will take ownership of the
   /// listener and free it when the context is destroyed.
   void addRunListener(PassRunListener *L);
   /// \brief Unregister a PassRunListener so that it no longer receives

lib/IR/DiagnosticInfo.cpp

 //===- llvm/Support/DiagnosticInfo.cpp - Diagnostic Definitions -*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines the different classes involved in low level diagnostics.
 //
 // Diagnostics reporting is still done as part of the LLVMContext.
 //===----------------------------------------------------------------------===//
 
+#include "LLVMContextImpl.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/DiagnosticPrinter.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Metadata.h"

 void DiagnosticInfoSampleProfile::print(DiagnosticPrinter &DP) const {
   if (getFileName() && getLineNum() > 0)
     DP << getFileName() << ":" << getLineNum() << ": ";
   else if (getFileName())
     DP << getFileName() << ": ";
   DP << getMsg();
 }
 
-bool DiagnosticInfoOptimizationRemark::isLocationAvailable() const {
+bool DiagnosticInfoOptimizationRemarkBase::isLocationAvailable() const {
   return getFunction().getParent()->getNamedMetadata("llvm.dbg.cu") != nullptr;
 }
 
-void DiagnosticInfoOptimizationRemark::getLocation(StringRef *Filename,
+void DiagnosticInfoOptimizationRemarkBase::getLocation(StringRef *Filename,
                                                        unsigned *Line,
                                                        unsigned *Column) const {
   DILocation DIL(getDebugLoc().getAsMDNode(getFunction().getContext()));
   *Filename = DIL.getFilename();
   *Line = DIL.getLineNumber();
   *Column = DIL.getColumnNumber();
 }
 
-const std::string DiagnosticInfoOptimizationRemark::getLocationStr() const {
+const std::string DiagnosticInfoOptimizationRemarkBase::getLocationStr() const {
   StringRef Filename("<unknown>");
   unsigned Line = 0;
   unsigned Column = 0;
   if (isLocationAvailable())
     getLocation(&Filename, &Line, &Column);
   return Twine(Filename + ":" + Twine(Line) + ":" + Twine(Column)).str();
 }
 
-void DiagnosticInfoOptimizationRemark::print(DiagnosticPrinter &DP) const {
+void DiagnosticInfoOptimizationRemarkBase::print(DiagnosticPrinter &DP) const {
   DP << getLocationStr() << ": " << getMsg();
 }
+
+bool
+DiagnosticInfoOptimizationRemark::isEnabled(LLVMContextImpl *pImpl) const {
+  return pImpl->optimizationRemarkEnabledFor(this);
+}
+
+bool DiagnosticInfoOptimizationRemarkMissed::isEnabled(
+    LLVMContextImpl *pImpl) const {
+  return pImpl->optimizationRemarkEnabledFor(this);
+}
+
+bool DiagnosticInfoOptimizationRemarkAnalysis::isEnabled(
+    LLVMContextImpl *pImpl) const {
+  return pImpl->optimizationRemarkEnabledFor(this);
+}

lib/IR/LLVMContext.cpp

 
 void LLVMContext::diagnose(const DiagnosticInfo &DI) {
   // If there is a report handler, use it.
   if (pImpl->DiagnosticHandler) {
     pImpl->DiagnosticHandler(DI, pImpl->DiagnosticContext);
     return;
   }
 
-  // Optimization remarks are selective. They need to check whether
-  // the regexp pattern, passed via -pass-remarks, matches the name
-  // of the pass that is emitting the diagnostic. If there is no match,
-  // ignore the diagnostic and return.
-  if (DI.getKind() == llvm::DK_OptimizationRemark &&
-      !pImpl->optimizationRemarksEnabledFor(
-          cast<DiagnosticInfoOptimizationRemark>(DI).getPassName()))
+  // Optimization remarks are selective. They need to check whether the regexp
+  // pattern, passed via one of the -pass-remarks* flags, matches the name of
+  // the pass that is emitting the diagnostic. If there is no match, ignore the
+  // diagnostic and return.
+  switch (DI.getKind()) {
+  case llvm::DK_OptimizationRemark:
+    if (!cast<DiagnosticInfoOptimizationRemark>(DI).isEnabled(pImpl))
       return;
+    break;
+  case llvm::DK_OptimizationRemarkMissed:
+    if (!cast<DiagnosticInfoOptimizationRemarkMissed>(DI).isEnabled(pImpl))
+      return;
+    break;
+  case llvm::DK_OptimizationRemarkAnalysis:
+    if (!cast<DiagnosticInfoOptimizationRemarkAnalysis>(DI).isEnabled(pImpl))
+      return;
+    break;
+  default:
+    break;
+  }
 
   // Otherwise, print the message with a prefix based on the severity.
   std::string MsgStorage;
   raw_string_ostream Stream(MsgStorage);
   DiagnosticPrinterRawOStream DP(Stream);
   DI.print(DP);
   Stream.flush();
   switch (DI.getSeverity()) {

 
 void LLVMContext::emitOptimizationRemark(const char *PassName,
                                          const Function &Fn,
                                          const DebugLoc &DLoc,
                                          const Twine &Msg) {
   diagnose(DiagnosticInfoOptimizationRemark(PassName, Fn, DLoc, Msg));
 }
 
+void LLVMContext::emitOptimizationRemarkMissed(const char *PassName,
+                                               const Function &Fn,
+                                               const DebugLoc &DLoc,
+                                               const Twine &Msg) {
+  diagnose(DiagnosticInfoOptimizationRemarkMissed(PassName, Fn, DLoc, Msg));
+}
+
+void LLVMContext::emitOptimizationRemarkAnalysis(const char *PassName,
+                                                 const Function &Fn,
+                                                 const DebugLoc &DLoc,
+                                                 const Twine &Msg) {
+  diagnose(DiagnosticInfoOptimizationRemarkAnalysis(PassName, Fn, DLoc, Msg));
+}
+
 //===----------------------------------------------------------------------===//
 // Metadata Kind Uniquing
 //===----------------------------------------------------------------------===//
 
 #ifndef NDEBUG
 /// isValidName - Return true if Name is a valid custom metadata handler name.
 static bool isValidName(StringRef MDName) {
   if (MDName.empty())

lib/IR/LLVMContextImpl.h

 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/ValueHandle.h"
 #include <vector>
 
 namespace llvm {
 
 class ConstantInt;
 class ConstantFP;
+class DiagnosticInfoOptimizationRemark;
+class DiagnosticInfoOptimizationRemarkMissed;
+class DiagnosticInfoOptimizationRemarkAnalysis;
 class LLVMContext;
 class Type;
 class Value;
 struct PassRunListener;
 
 struct DenseMapAPIntKeyInfo {
   struct KeyTy {
     APInt val;
public:
   typedef DenseMap<const Function *, ReturnInst *> PrefixDataMapTy;
   PrefixDataMapTy PrefixDataMap;
 
   /// \brief List of listeners to notify about a pass run.
   SmallVector<PassRunListener *, 4> RunListeners;
 
   /// \brief Return true if the given pass name should emit optimization
   /// remarks.
-  bool optimizationRemarksEnabledFor(const char *PassName) const;
+  bool optimizationRemarkEnabledFor(
+      const DiagnosticInfoOptimizationRemark *DI) const;
+  bool optimizationRemarkEnabledFor(
+      const DiagnosticInfoOptimizationRemarkMissed *DI) const;
+  bool optimizationRemarkEnabledFor(
+      const DiagnosticInfoOptimizationRemarkAnalysis *DI) const;
 
   int getOrAddScopeRecordIdxEntry(MDNode *N, int ExistingIdx);
   int getOrAddScopeInlinedAtIdxEntry(MDNode *Scope, MDNode *IA,int ExistingIdx);
 
   /// \brief Notify that we finished running a pass.
   void notifyPassRun(LLVMContext *, Pass *, Module *, Function *, BasicBlock *);
   /// \brief Register the given PassRunListener to receive notifyPassRun()
   /// callbacks whenever a pass ran. The context will take ownership of the

lib/IR/LLVMContextImpl.cpp

 //===-- LLVMContextImpl.cpp - Implement LLVMContextImpl -------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file implements the opaque LLVMContextImpl.
 //
 //===----------------------------------------------------------------------===//
 
 #include "LLVMContextImpl.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/IR/Attributes.h"
+#include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/Module.h"
 #include "llvm/PassSupport.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Regex.h"
 #include <algorithm>
 using namespace llvm;
 
 /// Notify that we finished running a pass.
LLVMContextImpl::LLVMContextImpl(LLVMContext &C)
   InlineAsmDiagContext = nullptr;
   DiagnosticHandler = nullptr;
   DiagnosticContext = nullptr;
   NamedStructTypesUniqueID = 0;
 }
 
 namespace {
 
-/// \brief Regular expression corresponding to the value given in the
-/// command line flag -pass-remarks. Passes whose name matches this
-/// regexp will emit a diagnostic when calling
-/// LLVMContext::emitOptimizationRemark.
-static Regex *OptimizationRemarkPattern = nullptr;
-
+/// \brief Regular expression corresponding to the value given in one of the
+/// -pass-remarks* command line flags. Passes whose name matches this regexp
+/// will emit a diagnostic when calling the associated diagnostic function
+/// (LLVMContext::emitOptimizationRemark,
+/// LLVMContext::emitOptimizationRemarkMissed or
+/// LLVMContext::emitOptimizationRemarkAnalysis).
 struct PassRemarksOpt {
-  void operator=(const std::string &Val) const {
+  std::shared_ptr<Regex> Pattern;
+
+  void operator=(const std::string &Val) {
     // Create a regexp object to match pass names for emitOptimizationRemark.
     if (!Val.empty()) {
-      delete OptimizationRemarkPattern;
-      OptimizationRemarkPattern = new Regex(Val);
+      Pattern = std::make_shared<Regex>(Val);
       std::string RegexError;
-      if (!OptimizationRemarkPattern->isValid(RegexError))
+      if (!Pattern->isValid(RegexError))
         report_fatal_error("Invalid regular expression '" + Val +
                                "' in -pass-remarks: " + RegexError,
                            false);
     }
   };
 };
 
 static PassRemarksOpt PassRemarksOptLoc;
+static PassRemarksOpt PassRemarksMissedOptLoc;
+static PassRemarksOpt PassRemarksAnalysisOptLoc;
 
 // -pass-remarks
 //    Command line flag to enable LLVMContext::emitOptimizationRemark()
-//    and LLVMContext::emitOptimizationNote() calls.
 static cl::opt<PassRemarksOpt, true, cl::parser<std::string>>
 PassRemarks("pass-remarks", cl::value_desc("pattern"),
             cl::desc("Enable optimization remarks from passes whose name match "
                      "the given regular expression"),
             cl::Hidden, cl::location(PassRemarksOptLoc), cl::ValueRequired,
             cl::ZeroOrMore);
-}
 
-bool
-LLVMContextImpl::optimizationRemarksEnabledFor(const char *PassName) const {
-  return OptimizationRemarkPattern &&
-         OptimizationRemarkPattern->match(PassName);
+// -pass-remarks-missed
+//    Command line flag to enable LLVMContext::emitOptimizationRemarkMissed()
+static cl::opt<PassRemarksOpt, true, cl::parser<std::string>> PassRemarksMissed(
+    "pass-remarks-missed", cl::value_desc("pattern"),
+    cl::desc("Enable missed optimization remarks from passes whose name match "
+             "the given regular expression"),
+    cl::Hidden, cl::location(PassRemarksMissedOptLoc), cl::ValueRequired,
+    cl::ZeroOrMore);
+
+// -pass-remarks-analysis
+//    Command line flag to enable LLVMContext::emitOptimizationRemarkAnalysis()
+static cl::opt<PassRemarksOpt, true, cl::parser<std::string>>
+PassRemarksAnalysis(
+    "pass-remarks-analysis", cl::value_desc("pattern"),
+    cl::desc(
+        "Enable optimization analysis remarks from passes whose name match "
+        "the given regular expression"),
+    cl::Hidden, cl::location(PassRemarksAnalysisOptLoc), cl::ValueRequired,
+    cl::ZeroOrMore);
 }
 
+bool LLVMContextImpl::optimizationRemarkEnabledFor(
+    const DiagnosticInfoOptimizationRemark *DI) const {
+  return PassRemarksOptLoc.Pattern &&
+         PassRemarksOptLoc.Pattern->match(DI->getPassName());
+}
+
+bool LLVMContextImpl::optimizationRemarkEnabledFor(
+    const DiagnosticInfoOptimizationRemarkMissed *DI) const {
+  return PassRemarksMissedOptLoc.Pattern &&
+         PassRemarksMissedOptLoc.Pattern->match(DI->getPassName());
+}
+
+bool LLVMContextImpl::optimizationRemarkEnabledFor(
+    const DiagnosticInfoOptimizationRemarkAnalysis *DI) const {
+  return PassRemarksAnalysisOptLoc.Pattern &&
+         PassRemarksAnalysisOptLoc.Pattern->match(DI->getPassName());
+}
 
 namespace {
 struct DropReferences {
   // Takes the value_type of a ConstantUniqueMap's internal map, whose 'second'
   // is a Constant*.
-  template<typename PairT>
-  void operator()(const PairT &P) {
+  template <typename PairT> void operator()(const PairT &P) {
     P.second->dropAllReferences();
   }
 };
 
 // Temporary - drops pair.first instead of second.
 struct DropFirst {
   // Takes the value_type of a ConstantUniqueMap's internal map, whose 'second'
   // is a Constant*.

lib/Transforms/IPO/Inliner.cpp

unsigned Inliner::getInlineThreshold(CallSite CS) const {
   if ((InlineLimit.getNumOccurrences() == 0 ||
        ColdThreshold.getNumOccurrences() > 0) && ColdCallee &&
       ColdThreshold < thres)
     thres = ColdThreshold;
 
   return thres;
 }
 
+static void emitOptimizationRemarkAnalysis(CallSite CS, const Twine &Msg) {
+  Function *Caller = CS.getCaller();
+  LLVMContext &Ctx = Caller->getContext();
+  DebugLoc DLoc = CS.getInstruction()->getDebugLoc();
+  Ctx.emitOptimizationRemarkAnalysis(DEBUG_TYPE, *Caller, DLoc, Msg);
+}
+
 /// shouldInline - Return true if the inliner should attempt to inline
 /// at the given CallSite.
 bool Inliner::shouldInline(CallSite CS) {
   InlineCost IC = getInlineCost(CS);
   
   if (IC.isAlways()) {
     DEBUG(dbgs() << "    Inlining: cost=always"
           << ", Call: " << *CS.getInstruction() << "\n");
+    emitOptimizationRemarkAnalysis(
+        CS, Twine(CS.getCalledFunction()->getName()) +
+                " should always be inlined (cost=always)");
     return true;
   }
   
   if (IC.isNever()) {
     DEBUG(dbgs() << "    NOT Inlining: cost=never"
           << ", Call: " << *CS.getInstruction() << "\n");
+    emitOptimizationRemarkAnalysis(
+        CS, Twine(CS.getCalledFunction()->getName() +
+                  " should never be inlined (cost=never)"));
     return false;
   }
   
   Function *Caller = CS.getCaller();
   if (!IC) {
     DEBUG(dbgs() << "    NOT Inlining: cost=" << IC.getCost()
           << ", thres=" << (IC.getCostDelta() + IC.getCost())
           << ", Call: " << *CS.getInstruction() << "\n");
+    emitOptimizationRemarkAnalysis(
+        CS, Twine(CS.getCalledFunction()->getName() +
+                  " too costly to inline (cost=") +
+                Twine(IC.getCost()) + ", threshold=" +
+                Twine(IC.getCostDelta() + IC.getCost()) + ")");
     return false;
   }
   
   // Try to detect the case where the current inlining candidate caller (call
   // it B) is a static or linkonce-ODR function and is an inlining candidate
   // elsewhere, and the current candidate callee (call it C) is large enough
   // that inlining it into B would make B too big to inline later. In these
   // circumstances it may be best not to inline C into B, but to inline B into
if (Caller->hasLocalLinkage() ||
     // is only one caller of Caller.
     if (callerWillBeRemoved && !Caller->use_empty())
       TotalSecondaryCost += InlineConstants::LastCallToStaticBonus;
 
     if (inliningPreventsSomeOuterInline && TotalSecondaryCost < IC.getCost()) {
       DEBUG(dbgs() << "    NOT Inlining: " << *CS.getInstruction() <<
            " Cost = " << IC.getCost() <<
            ", outer Cost = " << TotalSecondaryCost << '\n');
+      emitOptimizationRemarkAnalysis(
+          CS, Twine("Not inlining. Cost of inlining " +
+                    CS.getCalledFunction()->getName() +
+                    " increases the cost of inlining " +
+                    CS.getCaller()->getName() + " in other contexts"));
       return false;
     }
   }
 
   DEBUG(dbgs() << "    Inlining: cost=" << IC.getCost()
         << ", thres=" << (IC.getCostDelta() + IC.getCost())
         << ", Call: " << *CS.getInstruction() << '\n');
+  emitOptimizationRemarkAnalysis(
+      CS, CS.getCalledFunction()->getName() + Twine(" can be inlined into ") +
+              CS.getCaller()->getName() + " with cost=" + Twine(IC.getCost()) +
+              " (threshold=" + Twine(IC.getCostDelta() + IC.getCost()) + ")");
   return true;
 }
 
 /// InlineHistoryIncludes - Return true if the specified inline history ID
 /// indicates an inline history that includes the specified function.
 static bool InlineHistoryIncludes(Function *F, int InlineHistoryID,
             const SmallVectorImpl<std::pair<Function*, int> > &InlineHistory) {
   while (InlineHistoryID != -1) {
for (unsigned CSi = 0; CSi != CallSites.size(); ++CSi) {
         // itself.  If so, we'd be recursively inlining the same function,
         // which would provide the same callsites, which would cause us to
         // infinitely inline.
         int InlineHistoryID = CallSites[CSi].second;
         if (InlineHistoryID != -1 &&
             InlineHistoryIncludes(Callee, InlineHistoryID, InlineHistory))
           continue;
         
-        
+        LLVMContext &CallerCtx = Caller->getContext();
+
+        // Get DebugLoc to report. CS will be invalid after Inliner.
+        DebugLoc DLoc = CS.getInstruction()->getDebugLoc();
         // If the policy determines that we should inline this function,
         // try to do so.
-        if (!shouldInline(CS))
+        if (!shouldInline(CS)) {
+          CallerCtx.emitOptimizationRemarkMissed(
+              DEBUG_TYPE, *Caller, DLoc,
+              Twine(Callee->getName() + " will not be inlined into " +
+                    Caller->getName()));
           continue;
-
-        // Get DebugLoc to report. CS will be invalid after Inliner.
-        DebugLoc DLoc = CS.getInstruction()->getDebugLoc();
+        }
 
         // Attempt to inline the function.
         if (!InlineCallIfPossible(CS, InlineInfo, InlinedArrayAllocas,
-                                  InlineHistoryID, InsertLifetime, DL))
+                                  InlineHistoryID, InsertLifetime, DL)) {
+          CallerCtx.emitOptimizationRemarkMissed(
+              DEBUG_TYPE, *Caller, DLoc,
+              Twine(Callee->getName() + " will not be inlined into " +
+                    Caller->getName()));
           continue;
+        }
         ++NumInlined;
 
         // Report the inline decision.
-        Caller->getContext().emitOptimizationRemark(
+        CallerCtx.emitOptimizationRemark(
             DEBUG_TYPE, *Caller, DLoc,
             Twine(Callee->getName() + " inlined into " + Caller->getName()));
 
         // If inlining this function gave us any new call sites, throw them
         // onto our worklist to process.  They are useful inline candidates.
         if (!InlineInfo.InlinedCalls.empty()) {
           // Create a new inline history entry for this, so that we remember
           // that these new callsites came about due to inlining Callee.

test/Transforms/Inline/optimization-remarks.ll

+; RUN: opt < %s -inline -pass-remarks=inline -pass-remarks-missed=inline -pass-remarks-analysis=inline -S 2>&1 | FileCheck %s
+
+; CHECK: foo should always be inlined (cost=always)
+; CHECK: foo inlined into bar
+; CHECK: foz should never be inlined (cost=never)
+; CHECK: foz will not be inlined into bar
+
+; Function Attrs: alwaysinline nounwind uwtable
+define i32 @foo(i32 %x, i32 %y) #0 {
+entry:
+  %x.addr = alloca i32, align 4
+  %y.addr = alloca i32, align 4
+  store i32 %x, i32* %x.addr, align 4
+  store i32 %y, i32* %y.addr, align 4
+  %0 = load i32* %x.addr, align 4
+  %1 = load i32* %y.addr, align 4
+  %add = add nsw i32 %0, %1
+  ret i32 %add
+}
+
+; Function Attrs: noinline nounwind uwtable
+define float @foz(i32 %x, i32 %y) #1 {
+entry:
+  %x.addr = alloca i32, align 4
+  %y.addr = alloca i32, align 4
+  store i32 %x, i32* %x.addr, align 4
+  store i32 %y, i32* %y.addr, align 4
+  %0 = load i32* %x.addr, align 4
+  %1 = load i32* %y.addr, align 4
+  %mul = mul nsw i32 %0, %1
+  %conv = sitofp i32 %mul to float
+  ret float %conv
+}
+
+; Function Attrs: nounwind uwtable
+define i32 @bar(i32 %j) #2 {
+entry:
+  %j.addr = alloca i32, align 4
+  store i32 %j, i32* %j.addr, align 4
+  %0 = load i32* %j.addr, align 4
+  %1 = load i32* %j.addr, align 4
+  %sub = sub nsw i32 %1, 2
+  %call = call i32 @foo(i32 %0, i32 %sub)
+  %conv = sitofp i32 %call to float
+  %2 = load i32* %j.addr, align 4
+  %sub1 = sub nsw i32 %2, 2
+  %3 = load i32* %j.addr, align 4
+  %call2 = call float @foz(i32 %sub1, i32 %3)
+  %mul = fmul float %conv, %call2
+  %conv3 = fptosi float %mul to i32
+  ret i32 %conv3
+}
+
+attributes #0 = { alwaysinline nounwind uwtable "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #1 = { noinline nounwind uwtable "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #2 = { nounwind uwtable "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
+
+!llvm.ident = !{!0}
+
+!0 = metadata !{metadata !"clang version 3.5.0 "}