Add support for optimization reports.

[dnovillo]

Summary

This patch adds backend support for -Rpass=, which indicates the name
of the optimization pass that should emit remarks stating when it
made a transformation to the code.

Pass names are taken from their DEBUG_NAME definitions.

This is the back end counterpart for

http://llvm-reviews.chandlerc.com/D3226

[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.

[qcolombet]

Hi Diego,

We are missing a test case here + a few minor things to check/fix.

Thanks,
-Quentin

include/llvm/Transforms/IPO/PassManagerBuilder.h

19

Was this intended?
I do not see any other changes that require that.

lib/Transforms/IPO/Inliner.cpp

530

I’m not sure the lifetime of all the references you are using in Twine are long enough.

Could you double check that the things are not freed before you are using it (like the fix we had to do in r203996)?

[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.
• Add LLVMContext::emitOptimizationRemark to simplify client's code.
• Rename OptimizationReport to OptimizationRemark.
• Add DiagnosticInfoOptimizationRemark::getLocation(). This returns the source file name, line and column number from the remark's location information. Used by DiagnosticInfoOptimizationRemark::getLocationStr()

[dnovillo]

• Fix typo. Recover unrelated change.

[qcolombet]

Hi Diego,

LGTM.

Thanks,
-Quentin

include/llvm/IR/DiagnosticInfo.h

 namespace llvm {
 
 // Forward declarations.
 class DiagnosticPrinter;
 class Function;
 class Instruction;
 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_OptimizationReport,
   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 occured. If 0, no line number will
   /// be emitted in the message.
   unsigned LineNum;
 
   /// Message to report.
   const Twine &Msg;
 };
 
+/// Diagnostic information for optimization reports.
+class DiagnosticInfoOptimizationReport : public DiagnosticInfo {
+public:
+  DiagnosticInfoOptimizationReport(const char *PassName, const Function &Fn,
+                                   const DebugLoc &DLoc, const Twine &Msg)
+      : DiagnosticInfo(DK_OptimizationReport, 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_OptimizationReport;
+  }
+
+  /// 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 StringRef getLocationStr() const;
+
+  const char *getPassName() const { return PassName; }
+  const Function &getFunction() const { return Fn; }
+  const DebugLoc &getDebugLoc() const { return DLoc; }
+  const Twine &getMsg() const { return Msg; }
+
+private:
+  /// Name of the pass that triggers this report. If this matches the
+  /// regular expression given in -Rpass=regexp, then the remark will
+  /// be emitted.
+  const char *PassName;
+
+  /// Function where this diagnostic is triggered.
+  const Function &Fn;
+
+  /// Debug location where this diagnostic is triggered.
+  const DebugLoc &DLoc;
+
+  /// Message to report.
+  const Twine &Msg;
+};
+
 } // End namespace llvm
 
 #endif

include/llvm/Transforms/IPO/PassManagerBuilder.h

 // "standard" optimization sequence suitable for languages like C and C++.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TRANSFORMS_IPO_PASSMANAGERBUILDER_H
 #define LLVM_TRANSFORMS_IPO_PASSMANAGERBUILDER_H
 
 #include <vector>
+#include <string>
 
 namespace llvm {
 class TargetLibraryInfo;
 class Pass;
 
 // The old pass manager infrastructure is hidden in a legacy namespace now.
 namespace legacy {
 class PassManagerBase;

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 "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"
+#include "llvm/IR/Module.h"
 #include "llvm/Support/Atomic.h"
 #include <string>
 
 using namespace llvm;
 
 int llvm::getNextAvailablePluginDiagnosticKind() {
   static sys::cas_flag PluginKindID = DK_FirstPluginKind;
   return (int)sys::AtomicIncrement(&PluginKindID);

 
 void DiagnosticInfoSampleProfile::print(DiagnosticPrinter &DP) const {
   if (getFileName() && getLineNum() > 0)
     DP << getFileName() << ":" << getLineNum() << ": ";
   else if (getFileName())
     DP << getFileName() << ": ";
   DP << getMsg();
 }
+
+bool DiagnosticInfoOptimizationReport::isLocationAvailable() const {
+  return getFunction().getParent()->getNamedMetadata("llvm.dbg.cu") != 0;
+}
+
+const StringRef DiagnosticInfoOptimizationReport::getLocationStr() const {
+  StringRef Filename("<unknown>");
+  unsigned Line = 0;
+  unsigned Column = 0;
+  if (isLocationAvailable()) {
+    DILocation DIL(getDebugLoc().getAsMDNode(getFunction().getContext()));
+    Filename = DIL.getFilename();
+    Line = DIL.getLineNumber();
+    Column = DIL.getColumnNumber();
+  }
+  return Twine(Filename + ":" + Twine(Line) + ":" + Twine(Column)).str();
+}
+
+void DiagnosticInfoOptimizationReport::print(DiagnosticPrinter &DP) const {
+  DP << getLocationStr() << ": " << getMsg();
+}

lib/Transforms/IPO/Inliner.cpp

 #define DEBUG_TYPE "inline"
 #include "llvm/Transforms/IPO/InlinerPass.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/CallGraph.h"
 #include "llvm/Analysis/InlineCost.h"
 #include "llvm/IR/CallSite.h"
 #include "llvm/IR/DataLayout.h"
+#include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetLibraryInfo.h"
 #include "llvm/Transforms/Utils/Cloning.h"
for (unsigned CSi = 0; CSi != CallSites.size(); ++CSi) {
         if (!shouldInline(CS))
           continue;
 
         // Attempt to inline the function.
         if (!InlineCallIfPossible(CS, InlineInfo, InlinedArrayAllocas,
                                   InlineHistoryID, InsertLifetime, DL))
           continue;
         ++NumInlined;
-        
+        // Report the inline decision.
+        DiagnosticInfoOptimizationReport Diag(
+            DEBUG_TYPE, *Caller, CS.getInstruction()->getDebugLoc(),
+            Twine(Callee->getName() + " inlined into " + Caller->getName()));
+        Caller->getContext().diagnose(Diag);
+
         // 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.
           int NewHistoryID = InlineHistory.size();
           InlineHistory.push_back(std::make_pair(Callee, InlineHistoryID));