[WIP] Bug 32352 - Provide a way for OptimizationRemarkEmitter::allowExtraAnalysis to check if (specific) remarks are enabled

[vivekvpandya]

Summary

This patch first attempt to move isEnable() from DiagnosticInfo class to new class called DiagnosticHandler. I have still not moved emit() methods so I have still kept the call back. I am still having 8 lit test failing for this patch but I will solve the issues also my repo is not updated with upstream. I will fix all these issues and remaining tasks in upcoming updates. There is also very small change in clang's lib/CodeGen/CodeGenAction.cpp to assign clang's -Rpass option related shared pointers in DiagnosticHandler.
The motivation for this patch is to get early feedback so that I don't go into wrong direction.
Please provide feedback. This change also effects clang so I have added cfe-commits in subscriber .

[anemet]

This is going in the direction, IMO. Would also be good to see the clang patch at some point. Thanks for tackling this!

include/llvm/IR/DiagnosticHandler.h

21

We probably want to call this Passed... or something.

28

You should be able to return a combination of the Enable flags (e.g. Analysis | Missed | Passed).

include/llvm/IR/DiagnosticInfo.h

609–614

This occurs bunch of times, you probably want to put this in a function somewhere.

lib/IR/DiagnosticHandler.cpp

76–79

I think we only want one set of patterns count for each type, i.e. clang should just call a setter of DiagnosticHandler to override the one in LLVM (e.g. setMissedRemarkPassNamePattern).

[vivekvpandya]

Updated the patch but some cleanup is still to be done. For now I am focusing on correctness.

[anemet]

I only have high-level comments at this point because I don't think we're quite on the same page yet.

Also it would be good to actually see the new code for OptimizationRemarkEmitter::allowExtraAnalysis.

You also seems to have bunch of whitespace changes in this patch, please remove to make review easier.

include/llvm/IR/DiagnosticHandler.h

26–28

What is this for? handleDiagnostic should take the place of this.

28

You haven't address this comment.

[anemet]

include/llvm/IR/DiagnosticHandler.h

29

I believe that this needs to be virtual too but it depends on the mechanism of how ...

30–32

I am assuming you expect to use these from clang (currently unused)? I don't think that's how we want to do it. Clang should simply derive from this class and override handleDiagnostics and is*RemarkEnable according to its own logic.

33

handleDiagnostics

34–36

I think that these need to be virtual member functions. See previous comment about the clang interface.

tools/lto/lto.cpp

281–282

Use make_unique

[vivekvpandya]

include/llvm/IR/DiagnosticHandler.h

26–28

This is required for LLVM-C API users. We have discussed this in earlier emails.

28

I don't get the benefit of returning combination of the flags. What I understood is that remark can be for Analysis pass , applied/passed optimization or missed optimization. So that is why I kept four values for enum, three of them is as per above category and one for user not requested remarks for particular reg-ex.

30–32

Yes what you have think is correct about this. Also what you have suggested is better, but I kept it this way, the reason is in next comment.

34–36

I want there method to be static because -Rpass options are static cl::opt instance so if we want to just check if user has requested particular diagnostics through command line then it should be doable without passing object or pointer of DiagnosticHandler class. I feel we can make isRemadkEnable(...) a virtual method but there methods should be kept static. But these method to work correctly we need shared_ptr to RegEx (in clang's case too)

[anemet]

include/llvm/IR/DiagnosticHandler.h

34–36

This is what I am proposing:

include/IR/DiagnosticHandler.h:

class DiagnosticHandler {
public:
  virtual bool isAnalysisRemarkEnabled(StringRef PassName);
   ...
};

lib/IR/DiagnosticInfo.cpp:

static PassRemarksOpt PassRemarksOptLoc;

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 DiagnosticHandler::isPassedRemarkEnabled(StringRef PassName) {
    return PassRemarksOptLoc.Pattern &&
         PassRemarksOptLoc.Pattern->match(PassName);
}

tools/llc/llc.cpp:

Context.setDiagnosticHandler(make_unique<DiagnosticHandler>());

tools/clang/lib/CodeGen/CodeGenAction.cpp:

class ClangDiagnosticHandler final : public DiagnosticHandler {
public:
  ClangDiagnosticHandler(const CodeGenOptions &CodeGenOpts) ...

  bool isAnalysisRemarkEnabled(StringRef PassName) override {
        return (CodeGenOpts.OptimizationRemarkPattern &&
                    CodeGenOpts.OptimizationRemarkPattern->match(PassName));
  }
  ...

private:
  const CodeGenOptions &CodeGenOpts;
};

...

  Ctx.setDiagnosticHandler(make_unique<ClangDiagnosticHandler>(CodeGenOpts));

[vivekvpandya]

Update the patch.

[anemet]

This is getting close so besides the comments below, please also start cleaning up the patch so that the diff is as tight as possible. Thanks!

include/llvm/Analysis/OptimizationDiagnosticInfo.h

80–81

Take a StringRef.

85–87

No {} after else.

include/llvm/CodeGen/MachineOptimizationRemarkEmitter.h

78

No need for .str()

include/llvm/IR/DiagnosticHandler.h

30

struct?

34–39

There should be a comment here explaining the relationship of DiagHandlerCB and handleDiagnostics. I.e. DiagHandler is settable from the C API and default definition of handleDiagnostics calls this. On the other hand anything subclassing DiagHandler is not required to call the CB.

35

As per my allowExtraAnalysis comment, I would drop this for now along with the RemarkInfo struct. We can add this later if we need it.

39

I don't think this should take a DiagContext, since none of the overriding subclasses use it.

To satisfy the C API, DiagContext should be move to this class from the LLVMContext as well.

So the original version of handleDiagnostics should just call DiagHandlerCB(DI, DiagContextCB).

include/llvm/IR/DiagnosticInfo.h

18–28

Don't reorder these (i.e. use clang-format on the diff) and don't include anything you don't really need.

122

This is the same thing just written differently.

include/llvm/IR/LLVMContext.h

200–212

See my comments on the C API, I am hoping we can remove this,

include/llvm/LTO/Config.h

174–180

This should take the DiagnosticHandlerFunction in the ctor, stash it and then call it in handleDiagnostics().

183–187

Can you please add a FIXME here. I think that if Config were to use a unique_ptr of DiagnosticHandler class the ownership would be properly passed. This is not for this patch, but would be good to note down.

lib/Transforms/Vectorize/LoopVectorize.cpp

4969–4971

This case suggest that we should just make allowExtraAnalysis return a bool if any kind of remark is enabled for this pass. Then this can just be invoked as:

if (ORE->allowExtraAnalysis(DEBUG_TYPE))
   ...

[vivekvpandya]

Updated the patch!

[anemet]

include/llvm/Analysis/OptimizationDiagnosticInfo.h

80–81

Just StringRef, no need for const &, it's already a const ref. You have bunch of this in the patch.

81–83

no space after (

please clang-format the patch (https://clang.llvm.org/docs/ClangFormat.html#script-for-patch-reformatting)

83

You could also just return the boolean expression directly, no need for the if.

include/llvm/IR/DiagnosticHandler.h

16–34

Each function or public member needs a comment.

In particular, explain the return value for handleDiagnostics. I.e. true means the Diagnostics was handled (otherwise the default handler is executed).

18

New line before this.

21–22

DiagnosticHandler(void *DiagContext == nullptr)

and then you don't need the other ctor.

30

isAnyRemarkEnabled

Please fix all these names to use Enabled rather than Enable

You may also want move the definition here so that it gets inlined.

include/llvm/IR/DiagnosticInfo.h

36

This does not seem related to this change. Remove or commit separately.

include/llvm/IR/LLVMContext.h

18

clang-format to get this header in the right position (headers are alphabetically sorted).

200–211

Fix this weird / on each line.

222

Needs to return a const pointer if it's a const member function.

include/llvm/LTO/Config.h

174–180

You didn't fix this. To be clear this should take a DiagnosticHandlerFunction in the ctor and have a field t o store it rather than abusing Context.

lib/IR/DiagnosticInfo.cpp

235

I don't think you need the .str(). You have a bunch of this.

lib/IR/LLVMContext.cpp

223–226

Don't change these unrelated lines.

224–228

Make this a single if?

lib/LTO/LTOCodeGenerator.cpp

656–664

Here too, no need to abuse the Context for the pointer. Just have a new field for it in this subclass.

tools/llc/llc.cpp

163

Again don't abuse Context but have a field for HasError in this class.

237–238

Don't rename, remove. Also move the new class down here so that the diff is easier to read.

tools/llvm-dis/llvm-dis.cpp

129

Again have a field for this rather than using Context.

tools/llvm-link/llvm-link.cpp

184–185

Remove

tools/llvm-lto/llvm-lto.cpp

237–238

Remove.

866

Remove unrelated change.

[anemet]

You also need to add a test. You should be able to extend either the LICM's or the Vectorizer's test to also get the remarks due to allowExtraAnalysis with -pass-remarks not just with -pass-remarks-output.

[vivekvpandya]

Updated the patch , tests will be updated in next patch.

[vivekvpandya]

In D33514#859615, @anemet wrote:

You also need to add a test. You should be able to extend either the LICM's or the Vectorizer's test to also get the remarks due to allowExtraAnalysis with -pass-remarks not just with -pass-remarks-output.

If I understand this correctly then we need to remove -pass-remarks-output from all test which uses it just to return allowExtraAnalysis() true right? Also I think these kind of test uses llc .

include/llvm/IR/LLVMContext.h

18

clang-format -sort-includes gives me same result.

200–212

I don't think so as IR/Core.cpp uses this method to provide implantation of LLVM C API.

[anemet]

In D33514#861203, @vivekvpandya wrote:

In D33514#859615, @anemet wrote:

You also need to add a test. You should be able to extend either the LICM's or the Vectorizer's test to also get the remarks due to allowExtraAnalysis with -pass-remarks not just with -pass-remarks-output.

If I understand this correctly then we need to remove -pass-remarks-output from all test which uses it just to return allowExtraAnalysis() true right? Also I think these kind of test uses llc .

Not really. The test is actually GVN: test/Transforms/GVN/opt-remarks.ll. I just made some improvements in to make it more suitable to provide coverage for you these changes. Now the test should fail after your patch and you'd have to update the opt output testing. It should now print the "not eliminated" lines as well.

include/llvm/IR/LLVMContext.h

18

Perhaps written that way but it needs to be written as llvm/IR/DiagnosticHandler.h

200–212

Sorry that was an outdated comment that I've never finished, please ignore.

[anemet]

In D33514#861288, @anemet wrote:

Not really. The test is actually GVN: test/Transforms/GVN/opt-remarks.ll. I just made some improvements in

... in r312544.

[vivekvpandya]

Test Updated

[vivekvpandya]

@anemet if this looks oky to you then I can commit this on weekend.

[anemet]

Only minor things at this point. This is very close now.

include/llvm/Analysis/OptimizationDiagnosticInfo.h

81–83

Why rvalue reference, you should just take this by value. There is no ownership transfer here.

84

No std::move here. You have more of this later.

include/llvm/IR/DiagnosticHandler.h

14

I don't think you need this.

19

Please add a comment before the class.

20

No need for public for struct.

28

implementation

46

Capitalize first word and end with period; comments are full sentences.

58

I would drop the flag names here since if those are overridden this is not true. Just say "Return true if any remark type is enabled."

lib/IR/DiagnosticInfo.cpp

44–45

Is this still used here?

lib/LTO/LTOCodeGenerator.cpp

667–668

I think that this comment still applies.

tools/llvm-lto/llvm-lto.cpp

67–100

Don't move this code unless you have to. The diff is easier to read that way.

[anemet]

LGTM with the nits below. Thanks!

include/llvm/IR/DiagnosticHandler.h

2

DiagnosticHandler.h

lib/IR/LLVMContext.cpp

197

Remove this whitespace change

lib/IR/LLVMContextImpl.cpp

25–26

No need to pass nullptr here.

[vivekvpandya]

Update.

[vivekvpandya]

Added method to detach unique_ptr<DiagnosticHandler> from LLVMContext.

[anemet]

Still looks good.

lib/IR/LLVMContext.cpp

332

Has this version of the diff been clang-formatted?

[chapuni]

Fixed in rL313456.

include/llvm/IR/DiagnosticHandler.h

12

Did you forget include guard here?

include/llvm/Analysis/OptimizationDiagnosticInfo.h

public:
   void emit(DiagnosticInfoOptimizationBase &OptDiag);
 
   /// \brief Whether we allow for extra compile-time budget to perform more
   /// analysis to produce fewer false positives.
   ///
   /// This is useful when reporting missed optimizations.  In this case we can
   /// use the extra analysis (1) to filter trivial false positives or (2) to
   /// provide more context so that non-trivial false positives can be quickly
   /// detected by the user.
-  bool allowExtraAnalysis() const {
-    // For now, only allow this with -fsave-optimization-record since the -Rpass
-    // options are handled in the front-end.
-    return F->getContext().getDiagnosticsOutputFile();
+  bool allowExtraAnalysis(StringRef PassName) const {
+    return (F->getContext().getDiagnosticsOutputFile() ||
+            F->getContext().getDiagHandlerPtr()->isAnyRemarkEnabled(PassName));
   }
 
 private:
   const Function *F;
 
   BlockFrequencyInfo *BFI;
 
   /// If we generate BFI on demand, we need to free it when ORE is freed.
   std::unique_ptr<BlockFrequencyInfo> OwnedBFI;
 
   /// Compute hotness from IR value (currently assumed to be a block) if PGO is
   /// available.

include/llvm/CodeGen/MachineOptimizationRemarkEmitter.h

MachineOptimizationRemark(const char *PassName, StringRef RemarkName,
                                       RemarkName, Loc, MBB) {}
 
   static bool classof(const DiagnosticInfo *DI) {
     return DI->getKind() == DK_MachineOptimizationRemark;
   }
 
   /// \see DiagnosticInfoOptimizationBase::isEnabled.
   bool isEnabled() const override {
-    return OptimizationRemark::isEnabled(getPassName());
+    const Function &Fn = getFunction();
+    LLVMContext &Ctx = Fn.getContext();
+    return Ctx.getDiagHandlerPtr()->isPassedOptRemarkEnabled(getPassName());
   }
 };
 
 /// Diagnostic information for missed-optimization remarks.
 class MachineOptimizationRemarkMissed : public DiagnosticInfoMIROptimization {
 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 RemarkName is a textual identifier for the
   /// remark.  \p Loc is the debug location and \p MBB is the block that the
   /// optimization operates in.
   MachineOptimizationRemarkMissed(const char *PassName, StringRef RemarkName,
                                   const DiagnosticLocation &Loc,
                                   const MachineBasicBlock *MBB)
       : DiagnosticInfoMIROptimization(DK_MachineOptimizationRemarkMissed,
                                       PassName, RemarkName, Loc, MBB) {}
 
   static bool classof(const DiagnosticInfo *DI) {
     return DI->getKind() == DK_MachineOptimizationRemarkMissed;
   }
 
   /// \see DiagnosticInfoOptimizationBase::isEnabled.
   bool isEnabled() const override {
-    return OptimizationRemarkMissed::isEnabled(getPassName());
+    const Function &Fn = getFunction();
+    LLVMContext &Ctx = Fn.getContext();
+    return Ctx.getDiagHandlerPtr()->isMissedOptRemarkEnabled(getPassName());
   }
 };
 
 /// Diagnostic information for optimization analysis remarks.
 class MachineOptimizationRemarkAnalysis : public DiagnosticInfoMIROptimization {
 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 RemarkName is a textual identifier for the
   /// remark.  \p Loc is the debug location and \p MBB is the block that the
   /// optimization operates in.
   MachineOptimizationRemarkAnalysis(const char *PassName, StringRef RemarkName,
                                     const DiagnosticLocation &Loc,
                                     const MachineBasicBlock *MBB)
       : DiagnosticInfoMIROptimization(DK_MachineOptimizationRemarkAnalysis,
                                       PassName, RemarkName, Loc, MBB) {}
 
   static bool classof(const DiagnosticInfo *DI) {
     return DI->getKind() == DK_MachineOptimizationRemarkAnalysis;
   }
 
   /// \see DiagnosticInfoOptimizationBase::isEnabled.
   bool isEnabled() const override {
-    return OptimizationRemarkAnalysis::isEnabled(getPassName());
+    const Function &Fn = getFunction();
+    LLVMContext &Ctx = Fn.getContext();
+    return Ctx.getDiagHandlerPtr()->isAnalysisRemarkEnabled(getPassName());
   }
 };
 
 /// Extend llvm::ore:: with MI-specific helper names.
 namespace ore {
 using MNV = DiagnosticInfoMIROptimization::MachineArgument;
 }
 
public:
 
   /// \brief Whether we allow for extra compile-time budget to perform more
   /// analysis to be more informative.
   ///
   /// This is useful to enable additional missed optimizations to be reported
   /// that are normally too noisy.  In this mode, we can use the extra analysis
   /// (1) to filter trivial false positives or (2) to provide more context so
   /// that non-trivial false positives can be quickly detected by the user.
-  bool allowExtraAnalysis() const {
-    // For now, only allow this with -fsave-optimization-record since the -Rpass
-    // options are handled in the front-end.
-    return MF.getFunction()->getContext().getDiagnosticsOutputFile();
+  bool allowExtraAnalysis(StringRef PassName) const {
+    return (MF.getFunction()->getContext().getDiagnosticsOutputFile() ||
+            MF.getFunction()->getContext()
+            .getDiagHandlerPtr()->isAnyRemarkEnabled(PassName));
   }
 
 private:
   MachineFunction &MF;
 
   /// MBFI is only set if hotness is requested.
   MachineBlockFrequencyInfo *MBFI;
 

include/llvm/IR/DiagnosticHandler.h

+//===- DiagnosticHandler.h - DiagnosticHandler class for LLVM -*- C++ ---*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// Base DiagnosticHandler class declaration. Derive from this class to provide
+// custom diagnostic reporting.
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ADT/StringRef.h"
+
+namespace llvm {
+class DiagnosticInfo;
+
+/// \brief This is the base class for diagnostic handling in LLVM.
+/// The handleDiagnostics method must be overriden by the subclasses to handle
+/// diagnostic. The *RemarkEnabled methods can be overriden to control
+/// which remarks are enabled.
+struct DiagnosticHandler {
+  void *DiagnosticContext = nullptr;
+  DiagnosticHandler(void *DiagContext = nullptr)
+      : DiagnosticContext(DiagContext) {}
+  virtual ~DiagnosticHandler() = default;
+
+  using DiagnosticHandlerTy = void (*)(const DiagnosticInfo &DI, void *Context);
+
+  /// DiagHandlerCallback is settable from the C API and base implementation
+  /// of DiagnosticHandler will call it from handleDiagnostics(). Any derived
+  /// class of DiagnosticHandler should not use callback but
+  /// implement handleDiagnostics().
+  DiagnosticHandlerTy DiagHandlerCallback = nullptr;
+
+  /// Override handleDiagnostics to provide custom implementation.
+  /// Return true if it handles diagnostics reporting properly otherwise
+  /// return false to make LLVMContext::diagnose() to print the message
+  /// with a prefix based on the severity.
+  virtual bool handleDiagnostics(const DiagnosticInfo &DI) {
+    if (DiagHandlerCallback) {
+      DiagHandlerCallback(DI, DiagnosticContext);
+      return true;
+    }
+    return false;
+  }
+
+  /// Return true if analysis remarks are enabled, override
+  /// to provide different implementation.
+  virtual bool isAnalysisRemarkEnabled(StringRef PassName) const;
+
+  /// Return true if missed optimization remarks are enabled, override
+  /// to provide different implementation.
+  virtual bool isMissedOptRemarkEnabled(StringRef PassName) const;
+
+  /// Return true if passed optimization remarks are enabled, override
+  /// to provide different implementation.
+  virtual bool isPassedOptRemarkEnabled(StringRef PassName) const;
+
+  /// Return true if any type of remarks are enabled.
+  bool isAnyRemarkEnabled(StringRef PassName) const {
+    return (isMissedOptRemarkEnabled(PassName) ||
+            isPassedOptRemarkEnabled(PassName) ||
+            isAnalysisRemarkEnabled(PassName));
+  }
+};
+}

include/llvm/IR/DiagnosticInfo.h

 // This file declares the different classes involved in low level diagnostics.
 //
 // Diagnostics reporting is still done as part of the LLVMContext.
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_DIAGNOSTICINFO_H
 #define LLVM_IR_DIAGNOSTICINFO_H
 
 #include "llvm-c/Types.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/IR/DebugLoc.h"
 #include "llvm/Support/CBindingWrapping.h"
 #include "llvm/Support/YAMLTraits.h"
 #include <algorithm>
 #include <cstdint>
 #include <functional>
 #include <iterator>
 #include <string>
 
 namespace llvm {
 
 // Forward declarations.
 class DiagnosticPrinter;
 class Function;
 class Instruction;
 class LLVMContext;
 class Module;
 class SMDiagnostic;
 
 /// \brief Defines the different supported severity of a diagnostic.
 enum DiagnosticSeverity : char {
   DS_Error,
public:
   /// This is the default message that will be printed to the user.
   /// It is used when the frontend does not directly take advantage
   /// of the information contained in fields of the subclasses.
   /// The printed message must not end with '.' nor start with a severity
   /// keyword.
   virtual void print(DiagnosticPrinter &DP) const = 0;
 };
 
 using DiagnosticHandlerFunction = std::function<void(const DiagnosticInfo &)>;
 
 /// Diagnostic information for inline asm reporting.
 /// This is basically a message and an optional location.
 class DiagnosticInfoInlineAsm : public DiagnosticInfo {
 private:
   /// Optional line information. 0 if not set.
   unsigned LocCookie = 0;
   /// Message to be reported.
public:
   /// Func.
   OptimizationRemark(const char *PassName, StringRef RemarkName,
                      const Function *Func);
 
   static bool classof(const DiagnosticInfo *DI) {
     return DI->getKind() == DK_OptimizationRemark;
   }
 
-  static bool isEnabled(StringRef PassName);
-
   /// \see DiagnosticInfoOptimizationBase::isEnabled.
-  bool isEnabled() const override { return isEnabled(getPassName()); }
+  bool isEnabled() const override;
 
 private:
   /// This is deprecated now and only used by the function API below.
   /// \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 Loc 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.
   OptimizationRemark(const char *PassName, const Function &Fn,
                      const DiagnosticLocation &Loc, const Twine &Msg)
       : DiagnosticInfoIROptimization(DK_OptimizationRemark, DS_Remark, PassName,
public:
   /// location.
   OptimizationRemarkMissed(const char *PassName, StringRef RemarkName,
                            const Instruction *Inst);
 
   static bool classof(const DiagnosticInfo *DI) {
     return DI->getKind() == DK_OptimizationRemarkMissed;
   }
 
-  static bool isEnabled(StringRef PassName);
-
   /// \see DiagnosticInfoOptimizationBase::isEnabled.
-  bool isEnabled() const override { return isEnabled(getPassName()); }
+  bool isEnabled() const override;
 
 private:
   /// This is deprecated now and only used by the function API below.
   /// \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 Loc is the location information to use in the
   /// diagnostic. If line table information is available, the diagnostic
public:
   /// location.
   OptimizationRemarkAnalysis(const char *PassName, StringRef RemarkName,
                              const Instruction *Inst);
 
   static bool classof(const DiagnosticInfo *DI) {
     return DI->getKind() == DK_OptimizationRemarkAnalysis;
   }
 
-  static bool isEnabled(StringRef PassName);
-
   /// \see DiagnosticInfoOptimizationBase::isEnabled.
-  bool isEnabled() const override {
-    return shouldAlwaysPrint() || isEnabled(getPassName());
-  }
+  bool isEnabled() const override;
 
   static const char *AlwaysPrint;
 
   bool shouldAlwaysPrint() const { return getPassName() == AlwaysPrint; }
 
 protected:
   OptimizationRemarkAnalysis(enum DiagnosticKind Kind, const char *PassName,
                              const Function &Fn, const DiagnosticLocation &Loc,

include/llvm/IR/LLVMContext.h

 // This file declares LLVMContext, a container of "global" state in LLVM, such
 // as the global type and constant uniquing tables.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_LLVMCONTEXT_H
 #define LLVM_IR_LLVMCONTEXT_H
 
 #include "llvm-c/Types.h"
+#include "llvm/IR/DiagnosticHandler.h"
 #include "llvm/Support/CBindingWrapping.h"
 #include "llvm/Support/Options.h"
 #include <cstdint>
 #include <memory>
 #include <string>
 
 namespace llvm {
 
public:
   /// identifiers across the context.  Off by default.
   bool isODRUniquingDebugTypes() const;
   void enableDebugTypeODRUniquing();
   void disableDebugTypeODRUniquing();
 
   using InlineAsmDiagHandlerTy = void (*)(const SMDiagnostic&, void *Context,
                                           unsigned LocCookie);
 
-  /// Defines the type of a diagnostic handler.
-  /// \see LLVMContext::setDiagnosticHandler.
-  /// \see LLVMContext::diagnose.
-  using DiagnosticHandlerTy = void (*)(const DiagnosticInfo &DI, void *Context);
-
   /// Defines the type of a yield callback.
   /// \see LLVMContext::setYieldCallback.
   using YieldCallbackTy = void (*)(LLVMContext *Context, void *OpaqueHandle);
 
   /// setInlineAsmDiagnosticHandler - This method sets a handler that is invoked
   /// when problems with inline asm are detected by the backend.  The first
   /// argument is a function pointer and the second is a context pointer that
   /// gets passed into the DiagHandler.
   ///
   /// LLVMContext doesn't take ownership or interpret either of these
   /// pointers.
   void setInlineAsmDiagnosticHandler(InlineAsmDiagHandlerTy DiagHandler,
                                      void *DiagContext = nullptr);
 
   /// getInlineAsmDiagnosticHandler - Return the diagnostic handler set by
   /// setInlineAsmDiagnosticHandler.
   InlineAsmDiagHandlerTy getInlineAsmDiagnosticHandler() const;
 
   /// getInlineAsmDiagnosticContext - Return the diagnostic context set by
   /// setInlineAsmDiagnosticHandler.
   void *getInlineAsmDiagnosticContext() const;
 
-  /// setDiagnosticHandler - This method sets a handler that is invoked
-  /// when the backend needs to report anything to the user.  The first
-  /// argument is a function pointer and the second is a context pointer that
-  /// gets passed into the DiagHandler.  The third argument should be set to
+  /// setDiagnosticHandlerCallBack - This method sets a handler call back
+  /// that is invoked when the backend needs to report anything to the user.
+  /// The first argument is a function pointer and the second is a context pointer
+  /// that gets passed into the DiagHandler.  The third argument should be set to
   /// true if the handler only expects enabled diagnostics.
   ///
   /// LLVMContext doesn't take ownership or interpret either of these
   /// pointers.
-  void setDiagnosticHandler(DiagnosticHandlerTy DiagHandler,
-                            void *DiagContext = nullptr,
+  void setDiagnosticHandlerCallBack(
+      DiagnosticHandler::DiagnosticHandlerTy DiagHandler,
+      void *DiagContext = nullptr, bool RespectFilters = false);
+
+  /// setDiagnosticHandler - This method sets unique_ptr to object of DiagnosticHandler
+  /// to provide custom diagnostic handling. The first argument is unique_ptr of object
+  /// of type DiagnosticHandler or a derived of that.   The third argument should be
+  /// set to true if the handler only expects enabled diagnostics.
+  ///
+  /// Ownership of this pointer is moved to LLVMContextImpl.
+  void setDiagnosticHandler(std::unique_ptr<DiagnosticHandler> &&DH,
                             bool RespectFilters = false);
 
-  /// getDiagnosticHandler - Return the diagnostic handler set by
-  /// setDiagnosticHandler.
-  DiagnosticHandlerTy getDiagnosticHandler() const;
+  /// getDiagnosticHandlerCallBack - Return the diagnostic handler call back set by
+  /// setDiagnosticHandlerCallBack.
+  DiagnosticHandler::DiagnosticHandlerTy getDiagnosticHandlerCallBack() const;
 
   /// getDiagnosticContext - Return the diagnostic context set by
   /// setDiagnosticContext.
   void *getDiagnosticContext() const;
 
+  /// getDiagHandlerPtr - Returns const raw pointer of DiagnosticHandler set by
+  /// setDiagnosticHandler.
+  const DiagnosticHandler *getDiagHandlerPtr() const;
+
+  /// getDiagnosticHandler - transfers owenership of DiagnosticHandler unique_ptr
+  /// to caller.
+  std::unique_ptr<DiagnosticHandler> getDiagnosticHandler();
+
   /// \brief Return if a code hotness metric should be included in optimization
   /// diagnostics.
   bool getDiagnosticsHotnessRequested() const;
   /// \brief Set if a code hotness metric should be included in optimization
   /// diagnostics.
   void setDiagnosticsHotnessRequested(bool Requested);
 
   /// \brief Return the minimum hotness value a diagnostic would need in order

include/llvm/LTO/Config.h

struct Config {
   /// called, and writes the module to a bitcode file with a name prefixed by
   /// the given output file name, and (2) creates a resolution file whose name
   /// is prefixed by the given output file name and sets ResolutionFile to its
   /// file handle.
   Error addSaveTemps(std::string OutputFileName,
                      bool UseInputModulePath = false);
 };
 
+struct LTOLLVMDiagnosticHandler : public DiagnosticHandler {
+  DiagnosticHandlerFunction *Fn;
+  LTOLLVMDiagnosticHandler(DiagnosticHandlerFunction *DiagHandlerFn)
+      : Fn(DiagHandlerFn) {}
+  bool handleDiagnostics(const DiagnosticInfo &DI) override {
+    (*Fn)(DI);
+    return true;
+  }
+};
 /// A derived class of LLVMContext that initializes itself according to a given
 /// Config object. The purpose of this class is to tie ownership of the
 /// diagnostic handler to the context, as opposed to the Config object (which
 /// may be ephemeral).
+// FIXME: This should not be required as diagnostic handler is not callback.
 struct LTOLLVMContext : LLVMContext {
-  static void funcDiagHandler(const DiagnosticInfo &DI, void *Context) {
-    auto *Fn = static_cast<DiagnosticHandlerFunction *>(Context);
-    (*Fn)(DI);
-  }
 
   LTOLLVMContext(const Config &C) : DiagHandler(C.DiagHandler) {
     setDiscardValueNames(C.ShouldDiscardValueNames);
     enableDebugTypeODRUniquing();
-    setDiagnosticHandler(funcDiagHandler, &DiagHandler, true);
+    setDiagnosticHandler(
+        llvm::make_unique<LTOLLVMDiagnosticHandler>(&DiagHandler), true);
   }
   DiagnosticHandlerFunction DiagHandler;
 };
 
 }
 }
 
 #endif

include/llvm/LTO/legacy/LTOCodeGenerator.h

struct LTOCodeGenerator {
   /// assume builtins are present on the target.
   void setFreestanding(bool Enabled) { Freestanding = Enabled; }
 
   void setDiagnosticHandler(lto_diagnostic_handler_t, void *);
 
   LLVMContext &getContext() { return Context; }
 
   void resetMergedModule() { MergedModule.reset(); }
+  void DiagnosticHandler(const DiagnosticInfo &DI);
 
 private:
   void initializeLTOPasses();
 
   /// Verify the merged module on first call.
   ///
   /// Sets \a HasVerifiedInput on first call and doesn't run again on the same
   /// input.
   void verifyMergedModuleOnce();
 
   bool compileOptimizedToFile(const char **Name);
   void restoreLinkageForExternals();
   void applyScopeRestrictions();
   void preserveDiscardableGVs(
       Module &TheModule,
       llvm::function_ref<bool(const GlobalValue &)> mustPreserveGV);
 
   bool determineTarget();
   std::unique_ptr<TargetMachine> createTargetMachine();
 
-  static void DiagnosticHandler(const DiagnosticInfo &DI, void *Context);
-
-  void DiagnosticHandler2(const DiagnosticInfo &DI);
-
   void emitError(const std::string &ErrMsg);
   void emitWarning(const std::string &ErrMsg);
 
   void finishOptimizationRemarks();
 
   LLVMContext &Context;
   std::unique_ptr<Module> MergedModule;
   std::unique_ptr<Linker> TheLinker;

lib/IR/CMakeLists.txt

add_llvm_library(LLVMCore
   ConstantRange.cpp
   Constants.cpp
   Core.cpp
   DIBuilder.cpp
   DataLayout.cpp
   DebugInfo.cpp
   DebugInfoMetadata.cpp
   DebugLoc.cpp
+  DiagnosticHandler.cpp
   DiagnosticInfo.cpp
   DiagnosticPrinter.cpp
   Dominators.cpp
   Function.cpp
   GCOV.cpp
   GVMaterializer.cpp
   Globals.cpp
   IRBuilder.cpp

lib/IR/Core.cpp

LLVMContextRef LLVMContextCreate() {
   return wrap(new LLVMContext());
 }
 
 LLVMContextRef LLVMGetGlobalContext() { return wrap(&*GlobalContext); }
 
 void LLVMContextSetDiagnosticHandler(LLVMContextRef C,
                                      LLVMDiagnosticHandler Handler,
                                      void *DiagnosticContext) {
-  unwrap(C)->setDiagnosticHandler(
-      LLVM_EXTENSION reinterpret_cast<LLVMContext::DiagnosticHandlerTy>(
+  unwrap(C)->setDiagnosticHandlerCallBack(
+      LLVM_EXTENSION reinterpret_cast<DiagnosticHandler::DiagnosticHandlerTy>(
           Handler),
       DiagnosticContext);
 }
 
 LLVMDiagnosticHandler LLVMContextGetDiagnosticHandler(LLVMContextRef C) {
   return LLVM_EXTENSION reinterpret_cast<LLVMDiagnosticHandler>(
-      unwrap(C)->getDiagnosticHandler());
+      unwrap(C)->getDiagnosticHandlerCallBack());
 }
 
 void *LLVMContextGetDiagnosticContext(LLVMContextRef C) {
   return unwrap(C)->getDiagnosticContext();
 }
 
 void LLVMContextSetYieldCallback(LLVMContextRef C, LLVMYieldCallback Callback,
                                  void *OpaqueHandle) {

lib/IR/DiagnosticHandler.cpp

+//===- DiagnosticHandler.h - DiagnosticHandler class for LLVM -------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+//
+//===----------------------------------------------------------------------===//
+#include "llvm/IR/DiagnosticHandler.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/RegEx.h"
+
+using namespace llvm;
+
+namespace {
+
+/// \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
+/// (emitOptimizationRemark, emitOptimizationRemarkMissed or
+/// emitOptimizationRemarkAnalysis).
+struct PassRemarksOpt {
+  std::shared_ptr<Regex> Pattern;
+
+  void operator=(const std::string &Val) {
+    // Create a regexp object to match pass names for emitOptimizationRemark.
+    if (!Val.empty()) {
+      Pattern = std::make_shared<Regex>(Val);
+      std::string RegexError;
+      if (!Pattern->isValid(RegexError))
+        report_fatal_error("Invalid regular expression '" + Val +
+                               "' in -pass-remarks: " + RegexError,
+                           false);
+    }
+  }
+};
+
+static PassRemarksOpt PassRemarksPassedOptLoc;
+static PassRemarksOpt PassRemarksMissedOptLoc;
+static PassRemarksOpt PassRemarksAnalysisOptLoc;
+
+// -pass-remarks
+//    Command line flag to enable emitOptimizationRemark()
+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(PassRemarksPassedOptLoc), cl::ValueRequired,
+    cl::ZeroOrMore);
+
+// -pass-remarks-missed
+//    Command line flag to enable 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 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 DiagnosticHandler::isAnalysisRemarkEnabled(StringRef PassName) const {
+  return (PassRemarksAnalysisOptLoc.Pattern &&
+          PassRemarksAnalysisOptLoc.Pattern->match(PassName));
+}
+bool DiagnosticHandler::isMissedOptRemarkEnabled(StringRef PassName) const {
+  return (PassRemarksMissedOptLoc.Pattern &&
+          PassRemarksMissedOptLoc.Pattern->match(PassName));
+}
+bool DiagnosticHandler::isPassedOptRemarkEnabled(StringRef PassName) const {
+  return (PassRemarksPassedOptLoc.Pattern &&
+          PassRemarksPassedOptLoc.Pattern->match(PassName));
+}

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/IR/DiagnosticInfo.h"
+#include "LLVMContextImpl.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/DiagnosticPrinter.h"

 #include "llvm/Support/Regex.h"
 #include "llvm/Support/raw_ostream.h"
 #include <atomic>
 #include <cassert>
 #include <memory>
 #include <string>
 
 using namespace llvm;
 
-namespace {
-
-/// \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 via ORE->emit(...);
-struct PassRemarksOpt {
-  std::shared_ptr<Regex> Pattern;
-
-  void operator=(const std::string &Val) {
-    if (!Val.empty()) {
-      Pattern = std::make_shared<Regex>(Val);
-      std::string RegexError;
-      if (!Pattern->isValid(RegexError))
-        report_fatal_error("Invalid regular expression '" + Val +
-                               "' in -pass-remarks: " + RegexError,
-                           false);
-    }
-  }
-};
-
-} // end anonymous namespace
-
-static PassRemarksOpt PassRemarksOptLoc;
-static PassRemarksOpt PassRemarksMissedOptLoc;
-static PassRemarksOpt PassRemarksAnalysisOptLoc;
-
-// -pass-remarks
-//    Command line flag to enable optimization remarks
-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);
-
-// -pass-remarks-missed
-//    Command line flag to enable missed optimization remarks
-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 optimization analysis remarks
-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);
-
 int llvm::getNextAvailablePluginDiagnosticKind() {
   static std::atomic<int> PluginKindID(DK_FirstPluginKind);
   return ++PluginKindID;
 }
 
 const char *OptimizationRemarkAnalysis::AlwaysPrint = "";
 
 DiagnosticInfoInlineAsm::DiagnosticInfoInlineAsm(const Instruction &I,
                                                  const Twine &MsgStr,

 
 OptimizationRemark::OptimizationRemark(const char *PassName,
                                        StringRef RemarkName,
                                        const Function *Func)
     : DiagnosticInfoIROptimization(DK_OptimizationRemark, DS_Remark, PassName,
                                    RemarkName, *Func, Func->getSubprogram(),
                                    &getFirstFunctionBlock(Func)) {}
 
-bool OptimizationRemark::isEnabled(StringRef PassName) {
-  return PassRemarksOptLoc.Pattern &&
-         PassRemarksOptLoc.Pattern->match(PassName);
+bool OptimizationRemark::isEnabled() const {
+  const Function &Fn = getFunction();
+  LLVMContext &Ctx = Fn.getContext();
+  return Ctx.getDiagHandlerPtr()->isPassedOptRemarkEnabled(getPassName());
 }
 
 OptimizationRemarkMissed::OptimizationRemarkMissed(
     const char *PassName, StringRef RemarkName, const DiagnosticLocation &Loc,
     const Value *CodeRegion)
     : DiagnosticInfoIROptimization(
           DK_OptimizationRemarkMissed, DS_Remark, PassName, RemarkName,
           *cast<BasicBlock>(CodeRegion)->getParent(), Loc, CodeRegion) {}
 
 OptimizationRemarkMissed::OptimizationRemarkMissed(const char *PassName,
                                                    StringRef RemarkName,
                                                    const Instruction *Inst)
     : DiagnosticInfoIROptimization(DK_OptimizationRemarkMissed, DS_Remark,
                                    PassName, RemarkName,
                                    *Inst->getParent()->getParent(),
                                    Inst->getDebugLoc(), Inst->getParent()) {}
 
-bool OptimizationRemarkMissed::isEnabled(StringRef PassName) {
-  return PassRemarksMissedOptLoc.Pattern &&
-         PassRemarksMissedOptLoc.Pattern->match(PassName);
+bool OptimizationRemarkMissed::isEnabled() const {
+  const Function &Fn = getFunction();
+  LLVMContext &Ctx = Fn.getContext();
+  return Ctx.getDiagHandlerPtr()->isMissedOptRemarkEnabled(getPassName());
 }
 
 OptimizationRemarkAnalysis::OptimizationRemarkAnalysis(
     const char *PassName, StringRef RemarkName, const DiagnosticLocation &Loc,
     const Value *CodeRegion)
     : DiagnosticInfoIROptimization(
           DK_OptimizationRemarkAnalysis, DS_Remark, PassName, RemarkName,
           *cast<BasicBlock>(CodeRegion)->getParent(), Loc, CodeRegion) {}
 
 OptimizationRemarkAnalysis::OptimizationRemarkAnalysis(const char *PassName,
                                                        StringRef RemarkName,
                                                        const Instruction *Inst)
     : DiagnosticInfoIROptimization(DK_OptimizationRemarkAnalysis, DS_Remark,
                                    PassName, RemarkName,
                                    *Inst->getParent()->getParent(),
                                    Inst->getDebugLoc(), Inst->getParent()) {}
 
 OptimizationRemarkAnalysis::OptimizationRemarkAnalysis(
     enum DiagnosticKind Kind, const char *PassName, StringRef RemarkName,
     const DiagnosticLocation &Loc, const Value *CodeRegion)
     : DiagnosticInfoIROptimization(Kind, DS_Remark, PassName, RemarkName,
                                    *cast<BasicBlock>(CodeRegion)->getParent(),
                                    Loc, CodeRegion) {}
 
-bool OptimizationRemarkAnalysis::isEnabled(StringRef PassName) {
-  return PassRemarksAnalysisOptLoc.Pattern &&
-         PassRemarksAnalysisOptLoc.Pattern->match(PassName);
+bool OptimizationRemarkAnalysis::isEnabled() const {
+  const Function &Fn = getFunction();
+  LLVMContext &Ctx = Fn.getContext();
+  return Ctx.getDiagHandlerPtr()->isAnalysisRemarkEnabled(getPassName()) ||
+         shouldAlwaysPrint();
 }
 
 void DiagnosticInfoMIRParser::print(DiagnosticPrinter &DP) const {
   DP << Diagnostic;
 }
 
 DiagnosticInfoOptimizationFailure::DiagnosticInfoOptimizationFailure(
     const char *PassName, StringRef RemarkName, const DiagnosticLocation &Loc,

lib/IR/LLVMContext.cpp

 }
 
 /// getInlineAsmDiagnosticContext - Return the diagnostic context set by
 /// setInlineAsmDiagnosticHandler.
 void *LLVMContext::getInlineAsmDiagnosticContext() const {
   return pImpl->InlineAsmDiagContext;
 }
 
-void LLVMContext::setDiagnosticHandler(DiagnosticHandlerTy DiagnosticHandler,
-                                       void *DiagnosticContext,
-                                       bool RespectFilters) {
-  pImpl->DiagnosticHandler = DiagnosticHandler;
-  pImpl->DiagnosticContext = DiagnosticContext;
+void LLVMContext::setDiagnosticHandlerCallBack(
+    DiagnosticHandler::DiagnosticHandlerTy DiagnosticHandler,
+    void *DiagnosticContext, bool RespectFilters) {
+  pImpl->DiagHandler->DiagHandlerCallback = DiagnosticHandler;
+  pImpl->DiagHandler->DiagnosticContext = DiagnosticContext;
+  pImpl->RespectDiagnosticFilters = RespectFilters;
+}
+
+void LLVMContext::setDiagnosticHandler(std::unique_ptr<DiagnosticHandler> &&DH,
+  pImpl->DiagHandler = std::move(DH);
   pImpl->RespectDiagnosticFilters = RespectFilters;
 }
 
 void LLVMContext::setDiagnosticsHotnessRequested(bool Requested) {
   pImpl->DiagnosticsHotnessRequested = Requested;
 }
 bool LLVMContext::getDiagnosticsHotnessRequested() const {
   return pImpl->DiagnosticsHotnessRequested;

 yaml::Output *LLVMContext::getDiagnosticsOutputFile() {
   return pImpl->DiagnosticsOutputFile.get();
 }
 
 void LLVMContext::setDiagnosticsOutputFile(std::unique_ptr<yaml::Output> F) {
   pImpl->DiagnosticsOutputFile = std::move(F);
 }
 
-LLVMContext::DiagnosticHandlerTy LLVMContext::getDiagnosticHandler() const {
-  return pImpl->DiagnosticHandler;
+DiagnosticHandler::DiagnosticHandlerTy
+LLVMContext::getDiagnosticHandlerCallBack() const {
+  return pImpl->DiagHandler->DiagHandlerCallback;
 }
 
 void *LLVMContext::getDiagnosticContext() const {
-  return pImpl->DiagnosticContext;
+  return pImpl->DiagHandler->DiagnosticContext;
 }
 
 void LLVMContext::setYieldCallback(YieldCallbackTy Callback, void *OpaqueHandle)
 {
   pImpl->YieldCallback = Callback;
   pImpl->YieldOpaqueHandle = OpaqueHandle;
 }
 

 
 static bool isDiagnosticEnabled(const DiagnosticInfo &DI) {
   // 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.
   if (auto *Remark = dyn_cast<DiagnosticInfoOptimizationBase>(&DI))
     return Remark->isEnabled();
 
   return true;
 }
 
 const char *
 LLVMContext::getDiagnosticMessagePrefix(DiagnosticSeverity Severity) {
   switch (Severity) {
   case DS_Error:
     return "error";
   case DS_Warning:
     return "warning";
   case DS_Remark:
     return "remark";
   case DS_Note:
     return "note";
   }
   llvm_unreachable("Unknown DiagnosticSeverity");
 }
 
 void LLVMContext::diagnose(const DiagnosticInfo &DI) {
   // If there is a report handler, use it.
-  if (pImpl->DiagnosticHandler) {
-    if (!pImpl->RespectDiagnosticFilters || isDiagnosticEnabled(DI))
-      pImpl->DiagnosticHandler(DI, pImpl->DiagnosticContext);
+  if (pImpl->DiagHandler &&
+      (!pImpl->RespectDiagnosticFilters || isDiagnosticEnabled(DI)) &&
+      pImpl->DiagHandler->handleDiagnostics(DI))
     return;
-  }
 
   if (!isDiagnosticEnabled(DI))
     return;
 
   // Otherwise, print the message with a prefix based on the severity.
   DiagnosticPrinterRawOStream DP(errs());
   errs() << getDiagnosticMessagePrefix(DI.getSeverity()) << ": ";
   DI.print(DP);
   errs() << "\n";
   if (DI.getSeverity() == DS_Error)
     exit(1);
 }

 
 void LLVMContext::setDiscardValueNames(bool Discard) {
   pImpl->DiscardValueNames = Discard;
 }
 
 OptBisect &LLVMContext::getOptBisect() {
   return pImpl->getOptBisect();
 }
+
+const DiagnosticHandler *LLVMContext::getDiagHandlerPtr() const {
+  return pImpl->DiagHandler.get();
+}
+
+std::unique_ptr<DiagnosticHandler> LLVMContext::getDiagnosticHandler() {
+  return std::move(pImpl->DiagHandler);
+}
 No newline at end of file

lib/IR/LLVMContextImpl.h

 public:
   /// OwnedModules - The set of modules instantiated in this context, and which
   /// will be automatically deleted if this context is deleted.
   SmallPtrSet<Module*, 4> OwnedModules;
   
   LLVMContext::InlineAsmDiagHandlerTy InlineAsmDiagHandler = nullptr;
   void *InlineAsmDiagContext = nullptr;
 
-  LLVMContext::DiagnosticHandlerTy DiagnosticHandler = nullptr;
-  void *DiagnosticContext = nullptr;
+  std::unique_ptr<DiagnosticHandler> DiagHandler;
   bool RespectDiagnosticFilters = false;
   bool DiagnosticsHotnessRequested = false;
   uint64_t DiagnosticsHotnessThreshold = 0;
   std::unique_ptr<yaml::Output> DiagnosticsOutputFile;
 
   LLVMContext::YieldCallbackTy YieldCallback = nullptr;
   void *YieldOpaqueHandle = nullptr;
 

lib/IR/LLVMContextImpl.cpp

 #include "llvm/IR/Type.h"
 #include "llvm/Support/ManagedStatic.h"
 #include <cassert>
 #include <utility>
 
 using namespace llvm;
 
 LLVMContextImpl::LLVMContextImpl(LLVMContext &C)
-  : VoidTy(C, Type::VoidTyID),
+  : DiagHandler(llvm::make_unique<DiagnosticHandler>()),
+    VoidTy(C, Type::VoidTyID),
     LabelTy(C, Type::LabelTyID),
     HalfTy(C, Type::HalfTyID),
     FloatTy(C, Type::FloatTyID),
     DoubleTy(C, Type::DoubleTyID),
     MetadataTy(C, Type::MetadataTyID),
     TokenTy(C, Type::TokenTyID),
     X86_FP80Ty(C, Type::X86_FP80TyID),
     FP128Ty(C, Type::FP128TyID),

lib/LTO/LTOCodeGenerator.cpp

if (!CodegenOptions.empty()) {
     // ParseCommandLineOptions() expects argv[0] to be program name.
     std::vector<const char *> CodegenArgv(1, "libLLVMLTO");
     for (std::string &Arg : CodegenOptions)
       CodegenArgv.push_back(Arg.c_str());
     cl::ParseCommandLineOptions(CodegenArgv.size(), CodegenArgv.data());
   }
 }
 
-void LTOCodeGenerator::DiagnosticHandler(const DiagnosticInfo &DI,
-                                         void *Context) {
-  ((LTOCodeGenerator *)Context)->DiagnosticHandler2(DI);
-}
 
-void LTOCodeGenerator::DiagnosticHandler2(const DiagnosticInfo &DI) {
+void LTOCodeGenerator::DiagnosticHandler(const DiagnosticInfo &DI) {
   // Map the LLVM internal diagnostic severity to the LTO diagnostic severity.
   lto_codegen_diagnostic_severity_t Severity;
   switch (DI.getSeverity()) {
   case DS_Error:
     Severity = LTO_DS_ERROR;
     break;
   case DS_Warning:
     Severity = LTO_DS_WARNING;
void LTOCodeGenerator::DiagnosticHandler(const DiagnosticInfo &DI) {
   Stream.flush();
 
   // If this method has been called it means someone has set up an external
   // diagnostic handler. Assert on that.
   assert(DiagHandler && "Invalid diagnostic handler");
   (*DiagHandler)(Severity, MsgStorage.c_str(), DiagContext);
 }
 
+namespace {
+struct LTODiagnosticHandler : public DiagnosticHandler {
+  LTOCodeGenerator *CodeGenerator;
+  LTODiagnosticHandler(LTOCodeGenerator *CodeGenPtr)
+      : CodeGenerator(CodeGenPtr) {}
+  bool handleDiagnostics(const DiagnosticInfo &DI) override {
+    CodeGenerator->DiagnosticHandler(DI);
+    return true;
+  }
+};
+}
+
 void
 LTOCodeGenerator::setDiagnosticHandler(lto_diagnostic_handler_t DiagHandler,
                                        void *Ctxt) {
   this->DiagHandler = DiagHandler;
   this->DiagContext = Ctxt;
   if (!DiagHandler)
-    return Context.setDiagnosticHandler(nullptr, nullptr);
+    return Context.setDiagnosticHandler(nullptr);
   // Register the LTOCodeGenerator stub in the LLVMContext to forward the
   // diagnostic to the external DiagHandler.
-  Context.setDiagnosticHandler(LTOCodeGenerator::DiagnosticHandler, this,
-                               /* RespectFilters */ true);
+  Context.setDiagnosticHandler(llvm::make_unique<LTODiagnosticHandler>(this),
+                               true);
 }
 
 namespace {
 class LTODiagnosticInfo : public DiagnosticInfo {
   const Twine &Msg;
 public:
   LTODiagnosticInfo(const Twine &DiagMsg, DiagnosticSeverity Severity=DS_Error)
       : DiagnosticInfo(DK_Linker, Severity), Msg(DiagMsg) {}

lib/Transforms/Scalar/GVN.cpp

if (DepInfo.isClobber()) {
     // Nothing known about this clobber, have to be conservative
     DEBUG(
       // fast print dep, using operator<< on instruction is too slow.
       dbgs() << "GVN: load ";
       LI->printAsOperand(dbgs());
       Instruction *I = DepInfo.getInst();
       dbgs() << " is clobbered by " << *I << '\n';
     );
-
-    if (ORE->allowExtraAnalysis())
+    if (ORE->allowExtraAnalysis(DEBUG_TYPE))
       reportMayClobberedLoad(LI, DepInfo, DT, ORE);
 
     return false;
   }
   assert(DepInfo.isDef() && "follows from above");
 
   Instruction *DepInst = DepInfo.getInst();
 

lib/Transforms/Vectorize/LoopVectorize.cpp

bool LoopVectorizationLegality::canVectorizeWithIfConvert() {
   // We can if-convert this loop.
   return true;
 }
 
 bool LoopVectorizationLegality::canVectorize() {
   // Store the result and return it at the end instead of exiting early, in case
   // allowExtraAnalysis is used to report multiple reasons for not vectorizing.
   bool Result = true;
+  
+  bool DoExtraAnalysis = ORE->allowExtraAnalysis(DEBUG_TYPE);
+  if (DoExtraAnalysis)
   // We must have a loop in canonical form. Loops with indirectbr in them cannot
   // be canonicalized.
   if (!TheLoop->getLoopPreheader()) {
     ORE->emit(createMissedAnalysis("CFGNotUnderstood")
               << "loop control flow is not understood by vectorizer");
-    if (ORE->allowExtraAnalysis())
+  if (DoExtraAnalysis)
       Result = false;
     else
       return false;
   }
 
   // FIXME: The code is currently dead, since the loop gets sent to
   // LoopVectorizationLegality is already an innermost loop.
   //
   // We can only vectorize innermost loops.
   if (!TheLoop->empty()) {
     ORE->emit(createMissedAnalysis("NotInnermostLoop")
               << "loop is not the innermost loop");
-    if (ORE->allowExtraAnalysis())
+    if (DoExtraAnalysis)
       Result = false;
     else
       return false;
   }
 
   // We must have a single backedge.
   if (TheLoop->getNumBackEdges() != 1) {
     ORE->emit(createMissedAnalysis("CFGNotUnderstood")
               << "loop control flow is not understood by vectorizer");
-    if (ORE->allowExtraAnalysis())
+    if (DoExtraAnalysis)
       Result = false;
     else
       return false;
   }
 
   // We must have a single exiting block.
   if (!TheLoop->getExitingBlock()) {
     ORE->emit(createMissedAnalysis("CFGNotUnderstood")
               << "loop control flow is not understood by vectorizer");
-    if (ORE->allowExtraAnalysis())
+    if (DoExtraAnalysis)
       Result = false;
     else
       return false;
   }
 
   // We only handle bottom-tested loops, i.e. loop in which the condition is
   // checked at the end of each iteration. With that we can assume that all
   // instructions in the loop are executed the same number of times.
   if (TheLoop->getExitingBlock() != TheLoop->getLoopLatch()) {
     ORE->emit(createMissedAnalysis("CFGNotUnderstood")
               << "loop control flow is not understood by vectorizer");
-    if (ORE->allowExtraAnalysis())
+    if (DoExtraAnalysis)
       Result = false;
     else
       return false;
   }
 
   // We need to have a loop header.
   DEBUG(dbgs() << "LV: Found a loop: " << TheLoop->getHeader()->getName()
                << '\n');
 
   // Check if we can if-convert non-single-bb loops.
   unsigned NumBlocks = TheLoop->getNumBlocks();
   if (NumBlocks != 1 && !canVectorizeWithIfConvert()) {
     DEBUG(dbgs() << "LV: Can't if-convert the loop.\n");
-    if (ORE->allowExtraAnalysis())
+    if (DoExtraAnalysis)
       Result = false;
     else
       return false;
   }
 
   // Check if we can vectorize the instructions and CFG in this loop.
   if (!canVectorizeInstrs()) {
     DEBUG(dbgs() << "LV: Can't vectorize the instructions or CFG\n");
-    if (ORE->allowExtraAnalysis())
+    if (DoExtraAnalysis)
       Result = false;
     else
       return false;
   }
 
   // Go over each instruction and look at memory deps.
   if (!canVectorizeMemory()) {
     DEBUG(dbgs() << "LV: Can't vectorize due to memory conflicts\n");
-    if (ORE->allowExtraAnalysis())
+    if (DoExtraAnalysis)
       Result = false;
     else
       return false;
   }
 
   DEBUG(dbgs() << "LV: We can vectorize this loop"
                << (LAI->getRuntimePointerChecking()->Need
                        ? " (with a runtime bound check)"
bool LoopVectorizationLegality::canVectorize() {
   if (Hints->getForce() == LoopVectorizeHints::FK_Enabled)
     SCEVThreshold = PragmaVectorizeSCEVCheckThreshold;
 
   if (PSE.getUnionPredicate().getComplexity() > SCEVThreshold) {
     ORE->emit(createMissedAnalysis("TooManySCEVRunTimeChecks")
               << "Too many SCEV assumptions need to be made and checked "
               << "at runtime");
     DEBUG(dbgs() << "LV: Too many SCEV checks needed.\n");
-    if (ORE->allowExtraAnalysis())
+    if (DoExtraAnalysis)
       Result = false;
     else
       return false;
   }
 
   // Okay! We've done all the tests. If any have failed, return false. Otherwise
   // we can vectorize, and at this point we don't have any other mem analysis
   // which may limit our maximum vectorization factor, so just return true with

test/Transforms/GVN/opt-remarks.ll

 ; RUN: opt < %s -gvn -o /dev/null  -S -pass-remarks=gvn -pass-remarks-missed=gvn  \
 ; RUN:     2>&1 | FileCheck %s
 ; RUN: opt < %s -gvn -o /dev/null  -pass-remarks-output=%t -S
 ; RUN: cat %t | FileCheck -check-prefix=YAML %s
 
 ; RUN: opt < %s -aa-pipeline=basic-aa -passes=gvn -o /dev/null -S -pass-remarks=gvn -pass-remarks-missed=gvn \
 ; RUN:     2>&1 | FileCheck %s
 ; RUN: opt < %s -aa-pipeline=basic-aa -passes=gvn -o /dev/null -pass-remarks-output=%t -S
 ; RUN: cat %t | FileCheck -check-prefix=YAML %s
 
 ; CHECK:      remark: <unknown>:0:0: load of type i32 eliminated{{$}}
 ; CHECK-NEXT: remark: <unknown>:0:0: load of type i32 eliminated{{$}}
 ; CHECK-NEXT: remark: <unknown>:0:0: load of type i32 eliminated{{$}}
-; CHECK-NOT:  remark:
+; CHECK-NEXT: remark: /tmp/s.c:3:3: load of type i32 not eliminated
 
 ; YAML:      --- !Passed
 ; YAML-NEXT: Pass:            gvn
 ; YAML-NEXT: Name:            LoadElim
 ; YAML-NEXT: Function:        arg
 ; YAML-NEXT: Args:
 ; YAML-NEXT:   - String:          'load of type '
 ; YAML-NEXT:   - Type:            i32

tools/llc/llc.cpp

void operator=(const std::string &Val) const {
     for (auto PassName : PassNames)
       RunPassNames->push_back(PassName);
   }
 };
 }
 
 static RunPassOption RunPassOpt;
 
 static cl::opt<RunPassOption, true, cl::parser<std::string>> RunPass(
     "run-pass",
     cl::desc("Run compiler only for specified passes (comma separated list)"),
     cl::value_desc("pass-name"), cl::ZeroOrMore, cl::location(RunPassOpt));
 
 static int compileModule(char **, LLVMContext &);
 
 static std::unique_ptr<tool_output_file>
 GetOutputStream(const char *TargetName, Triple::OSType OS,
auto FDOut = llvm::make_unique<tool_output_file>(OutputFilename, EC,
                                                    OpenFlags);
   if (EC) {
     errs() << EC.message() << '\n';
     return nullptr;
   }
 
   return FDOut;
 }
 
-static void DiagnosticHandler(const DiagnosticInfo &DI, void *Context) {
-  bool *HasError = static_cast<bool *>(Context);
+struct LLCDiagnosticHandler : public DiagnosticHandler {
+  bool *HasError;
+  LLCDiagnosticHandler(bool *HasErrorPtr) : HasError(HasErrorPtr) {}
+  bool handleDiagnostics(const DiagnosticInfo &DI) override {
     if (DI.getSeverity() == DS_Error)
       *HasError = true;
 
     if (auto *Remark = dyn_cast<DiagnosticInfoOptimizationBase>(&DI))
       if (!Remark->isEnabled())
-      return;
+        return true;
 
     DiagnosticPrinterRawOStream DP(errs());
     errs() << LLVMContext::getDiagnosticMessagePrefix(DI.getSeverity()) << ": ";
     DI.print(DP);
     errs() << "\n";
+    return true;
   }
+};
 
 static void InlineAsmDiagHandler(const SMDiagnostic &SMD, void *Context,
                                  unsigned LocCookie) {
   bool *HasError = static_cast<bool *>(Context);
   if (SMD.getKind() == SourceMgr::DK_Error)
     *HasError = true;
 
   SMD.print(nullptr, errs());
int main(int argc, char **argv) {
   cl::AddExtraVersionPrinter(TargetRegistry::printRegisteredTargetsForVersion);
 
   cl::ParseCommandLineOptions(argc, argv, "llvm system compiler\n");
 
   Context.setDiscardValueNames(DiscardValueNames);
 
   // Set a diagnostic handler that doesn't exit on the first error
   bool HasError = false;
-  Context.setDiagnosticHandler(DiagnosticHandler, &HasError);
+  Context.setDiagnosticHandler(
+      llvm::make_unique<LLCDiagnosticHandler>(&HasError));
   Context.setInlineAsmDiagnosticHandler(InlineAsmDiagHandler, &HasError);
 
   if (PassRemarksWithHotness)
     Context.setDiagnosticsHotnessRequested(true);
 
   if (PassRemarksHotnessThreshold)
     Context.setDiagnosticsHotnessThreshold(PassRemarksHotnessThreshold);
 
if (CompileTwice) {
       std::unique_ptr<Module> M2(llvm::CloneModule(M.get()));
       PM.run(*M2);
       CompileTwiceBuffer = Buffer;
       Buffer.clear();
     }
 
     PM.run(*M);
 
-    auto HasError = *static_cast<bool *>(Context.getDiagnosticContext());
-    if (HasError)
+    auto HasError =
+        ((const LLCDiagnosticHandler *)(Context.getDiagHandlerPtr()))->HasError;
+    if (*HasError)
       return 1;
 
     // Compare the two outputs and make sure they're the same
     if (CompileTwice) {
       if (Buffer.size() != CompileTwiceBuffer.size() ||
           (memcmp(Buffer.data(), CompileTwiceBuffer.data(), Buffer.size()) !=
            0)) {
         errs()

tools/llvm-dis/llvm-dis.cpp

if (const Instruction *I = dyn_cast<Instruction>(&V)) {
           OS << ";";
         }
         OS << " [debug variable = " << DVI->getVariable()->getName() << "]";
       }
     }
   }
 };
 
-} // end anon namespace
-
-static void diagnosticHandler(const DiagnosticInfo &DI, void *Context) {
+struct LLVMDisDiagnosticHandler : public DiagnosticHandler {
+  char *Prefix;
+  LLVMDisDiagnosticHandler(char *PrefixPtr) : Prefix(PrefixPtr) {}
+  bool handleDiagnostics(const DiagnosticInfo &DI) override {
     raw_ostream &OS = errs();
-  OS << (char *)Context << ": ";
+    OS << Prefix << ": ";
     switch (DI.getSeverity()) {
       case DS_Error: OS << "error: "; break;
       case DS_Warning: OS << "warning: "; break;
       case DS_Remark: OS << "remark: "; break;
       case DS_Note: OS << "note: "; break;
     }
 
     DiagnosticPrinterRawOStream DP(OS);
     DI.print(DP);
     OS << '\n';
 
     if (DI.getSeverity() == DS_Error)
       exit(1);
+    return true;
   }
+};
+} // end anon namespace
 
 static ExitOnError ExitOnErr;
 
 static std::unique_ptr<Module> openInputFile(LLVMContext &Context) {
   std::unique_ptr<MemoryBuffer> MB =
       ExitOnErr(errorOrToExpected(MemoryBuffer::getFileOrSTDIN(InputFilename)));
   std::unique_ptr<Module> M = ExitOnErr(getOwningLazyBitcodeModule(
       std::move(MB), Context,
int main(int argc, char **argv) {
   // Print a stack trace if we signal out.
   sys::PrintStackTraceOnErrorSignal(argv[0]);
   PrettyStackTraceProgram X(argc, argv);
 
   ExitOnErr.setBanner(std::string(argv[0]) + ": error: ");
 
   LLVMContext Context;
   llvm_shutdown_obj Y;  // Call llvm_shutdown() on exit.
-
-  Context.setDiagnosticHandler(diagnosticHandler, argv[0]);
-
+  Context.setDiagnosticHandler(
+      llvm::make_unique<LLVMDisDiagnosticHandler>(argv[0]));
   cl::ParseCommandLineOptions(argc, argv, "llvm .bc -> .ll disassembler\n");
 
   std::unique_ptr<Module> M = openInputFile(Context);
 
   // Just use stdout.  We won't actually print anything on it.
   if (DontPrint)
     OutputFilename = "-";
 

tools/llvm-link/llvm-link.cpp

 Module &ModuleLazyLoaderCache::operator()(const char *argv0,
                                           const std::string &Identifier) {
   auto &Module = ModuleMap[Identifier];
   if (!Module)
     Module = createLazyModule(argv0, Identifier);
   return *Module;
 }
 } // anonymous namespace
 
-static void diagnosticHandler(const DiagnosticInfo &DI, void *C) {
+namespace {
+struct LLVMLinkDiagnosticHandler : public DiagnosticHandler {
+  bool handleDiagnostics(const DiagnosticInfo &DI) override {
     unsigned Severity = DI.getSeverity();
     switch (Severity) {
     case DS_Error:
       errs() << "ERROR: ";
       break;
     case DS_Warning:
       if (SuppressWarnings)
-      return;
+        return true;
       errs() << "WARNING: ";
       break;
     case DS_Remark:
     case DS_Note:
       llvm_unreachable("Only expecting warnings and errors");
     }
 
     DiagnosticPrinterRawOStream DP(errs());
     DI.print(DP);
     errs() << '\n';
+    return true;
+  }
+};
 }
 
 /// Import any functions requested via the -import option.
 static bool importFunctions(const char *argv0, Module &DestModule) {
   if (SummaryIndex.empty())
     return true;
   std::unique_ptr<ModuleSummaryIndex> Index =
       ExitOnErr(llvm::getModuleSummaryIndexForFile(SummaryIndex));

 int main(int argc, char **argv) {
   // Print a stack trace if we signal out.
   sys::PrintStackTraceOnErrorSignal(argv[0]);
   PrettyStackTraceProgram X(argc, argv);
 
   ExitOnErr.setBanner(std::string(argv[0]) + ": ");
 
   LLVMContext Context;
-  Context.setDiagnosticHandler(diagnosticHandler, nullptr, true);
-
+  Context.setDiagnosticHandler(
+    llvm::make_unique<LLVMLinkDiagnosticHandler>(), true);
   llvm_shutdown_obj Y;  // Call llvm_shutdown() on exit.
   cl::ParseCommandLineOptions(argc, argv, "llvm linker\n");
 
   if (!DisableDITypeMap)
     Context.enableDebugTypeODRUniquing();
 
   auto Composite = make_unique<Module>("llvm-link", Context);
   Linker L(*Composite);

tools/llvm-lto/llvm-lto.cpp

 #include <memory>
 #include <string>
 #include <system_error>
 #include <tuple>
 #include <utility>
 #include <vector>
 
 using namespace llvm;
 
 static cl::opt<char>
     OptLevel("O", cl::desc("Optimization level. [-O0, -O1, -O2, or -O3] "
                            "(default = '-O2')"),
              cl::Prefix, cl::ZeroOrMore, cl::init('2'));
 
 static cl::opt<bool>
     IndexStats("thinlto-index-stats",
                cl::desc("Print statistic for the index in every input files"),
                cl::init(false));
 
 static cl::opt<bool> DisableVerify(
     "disable-verify", cl::init(false),
     cl::desc("Do not run the verifier during the optimization pipeline"));
 
 static cl::opt<bool> DisableInline("disable-inlining", cl::init(false),
                                    cl::desc("Do not run the inliner pass"));
 
 static cl::opt<bool>
     DisableGVNLoadPRE("disable-gvn-loadpre", cl::init(false),
                       cl::desc("Do not run the GVN load PRE pass"));
 
 static cl::opt<bool> DisableLTOVectorization(
     "disable-lto-vectorization", cl::init(false),
     cl::desc("Do not run loop or slp vectorization during LTO"));
 
 static cl::opt<bool> EnableFreestanding(
     "lto-freestanding", cl::init(false),
     cl::desc("Enable Freestanding (disable builtins / TLI) during LTO"));
 
 static cl::opt<bool> UseDiagnosticHandler(
     "use-diagnostic-handler", cl::init(false),
     cl::desc("Use a diagnostic handler to test the handler interface"));
 
 static cl::opt<bool>
     ThinLTO("thinlto", cl::init(false),
             cl::desc("Only write combined global index for ThinLTO backends"));
 
 enum ThinLTOModes {
   THINLINK,
   THINDISTRIBUTE,
   THINEMITIMPORTS,
case LTO_DS_ERROR:
     break;
   case LTO_DS_WARNING:
     errs() << "warning: ";
     break;
   }
   errs() << Msg << "\n";
 }
 
 static std::string CurrentActivity;
-static void diagnosticHandler(const DiagnosticInfo &DI, void *Context) {
+
+namespace {
+  struct LLVMLTODiagnosticHandler : public DiagnosticHandler {
+    bool handleDiagnostics(const DiagnosticInfo &DI) override {
       raw_ostream &OS = errs();
       OS << "llvm-lto: ";
       switch (DI.getSeverity()) {
       case DS_Error:
         OS << "error";
         break;
       case DS_Warning:
         OS << "warning";
         break;
       case DS_Remark:
         OS << "remark";
         break;
       case DS_Note:
         OS << "note";
         break;
       }
       if (!CurrentActivity.empty())
         OS << ' ' << CurrentActivity;
       OS << ": ";
   
       DiagnosticPrinterRawOStream DP(OS);
       DI.print(DP);
       OS << '\n';
   
       if (DI.getSeverity() == DS_Error)
         exit(1);
+      return true;
+    }
+  };
   }
 
 static void error(const Twine &Msg) {
   errs() << "llvm-lto: " << Msg << '\n';
   exit(1);
 }
 
 static void error(std::error_code EC, const Twine &Prefix) {
   if (EC)

 getLocalLTOModule(StringRef Path, std::unique_ptr<MemoryBuffer> &Buffer,
                   const TargetOptions &Options) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
       MemoryBuffer::getFile(Path);
   error(BufferOrErr, "error loading file '" + Path + "'");
   Buffer = std::move(BufferOrErr.get());
   CurrentActivity = ("loading file '" + Path + "'").str();
   std::unique_ptr<LLVMContext> Context = llvm::make_unique<LLVMContext>();
-  Context->setDiagnosticHandler(diagnosticHandler, nullptr, true);
+  Context->setDiagnosticHandler(llvm::make_unique<LLVMLTODiagnosticHandler>(),
+                                true);
   ErrorOr<std::unique_ptr<LTOModule>> Ret = LTOModule::createInLocalContext(
       std::move(Context), Buffer->getBufferStart(), Buffer->getBufferSize(),
       Options, Path);
   CurrentActivity = "";
   maybeVerifyModule((*Ret)->getModule());
   return std::move(*Ret);
 }
 
int main(int argc, char **argv) {
   if (ThinLTO) {
     createCombinedModuleSummaryIndex();
     return 0;
   }
 
   unsigned BaseArg = 0;
 
   LLVMContext Context;
-  Context.setDiagnosticHandler(diagnosticHandler, nullptr, true);
+  Context.setDiagnosticHandler(llvm::make_unique<LLVMLTODiagnosticHandler>(),
+                               true);
 
   LTOCodeGenerator CodeGen(Context);
 
   if (UseDiagnosticHandler)
     CodeGen.setDiagnosticHandler(handleDiagnostics, nullptr);
 
   CodeGen.setCodePICModel(getRelocModel());
   CodeGen.setFreestanding(EnableFreestanding);
int main(int argc, char **argv) {
   std::vector<std::string> KeptDSOSyms;
 
   for (unsigned i = BaseArg; i < InputFilenames.size(); ++i) {
     CurrentActivity = "loading file '" + InputFilenames[i] + "'";
     ErrorOr<std::unique_ptr<LTOModule>> ModuleOrErr =
         LTOModule::createFromFile(Context, InputFilenames[i], Options);
     std::unique_ptr<LTOModule> &Module = *ModuleOrErr;
     CurrentActivity = "";
 
     unsigned NumSyms = Module->getSymbolCount();
     for (unsigned I = 0; I < NumSyms; ++I) {
       StringRef Name = Module->getSymbolName(I);
       if (!DSOSymbolsSet.count(Name))
         continue;
       lto_symbol_attributes Attrs = Module->getSymbolAttributes(I);
       unsigned Scope = Attrs & LTO_SYMBOL_SCOPE_MASK;
       if (Scope != LTO_SYMBOL_SCOPE_DEFAULT_CAN_BE_HIDDEN)

tools/lto/lto.cpp

 // *** Not thread safe ***
 static bool initialized = false;
 
 // Holds the command-line option parsing state of the LTO module.
 static bool parsedOptions = false;
 
 static LLVMContext *LTOContext = nullptr;
 
-static void diagnosticHandler(const DiagnosticInfo &DI, void *Context) {
+struct LTOToolDiagnosticHandler : public DiagnosticHandler {
+  bool handleDiagnostics(const DiagnosticInfo &DI) override {
     if (DI.getSeverity() != DS_Error) {
       DiagnosticPrinterRawOStream DP(errs());
       DI.print(DP);
       errs() << '\n';
-    return;
+      return true;
     }
     sLastErrorString = "";
     {
       raw_string_ostream Stream(sLastErrorString);
       DiagnosticPrinterRawOStream DP(Stream);
       DI.print(DP);
     }
+    return true;
   }
+};
 
 // Initialize the configured targets if they have not been initialized.
 static void lto_initialize() {
   if (!initialized) {
 #ifdef LLVM_ON_WIN32
     // Dialog box on crash disabling doesn't work across DLL boundaries, so do
     // it here.
     llvm::sys::DisableSystemDialogsOnCrash();
 #endif
 
     InitializeAllTargetInfos();
     InitializeAllTargets();
     InitializeAllTargetMCs();
     InitializeAllAsmParsers();
     InitializeAllAsmPrinters();
     InitializeAllDisassemblers();
 
     static LLVMContext Context;
     LTOContext = &Context;
-    LTOContext->setDiagnosticHandler(diagnosticHandler, nullptr, true);
+    LTOContext->setDiagnosticHandler(
+        llvm::make_unique<LTOToolDiagnosticHandler>(), true);
     initialized = true;
   }
 }
 
 namespace {
 
 static void handleLibLTODiagnostic(lto_codegen_diagnostic_severity_t Severity,
                                    const char *Msg, void *) {

 
 lto_module_t lto_module_create_in_local_context(const void *mem, size_t length,
                                                 const char *path) {
   lto_initialize();
   llvm::TargetOptions Options = InitTargetOptionsFromCodeGenFlags();
 
   // Create a local context. Ownership will be transferred to LTOModule.
   std::unique_ptr<LLVMContext> Context = llvm::make_unique<LLVMContext>();
-  Context->setDiagnosticHandler(diagnosticHandler, nullptr, true);
+  Context->setDiagnosticHandler(llvm::make_unique<LTOToolDiagnosticHandler>(),
+                                true);
 
   ErrorOr<std::unique_ptr<LTOModule>> M = LTOModule::createInLocalContext(
       std::move(Context), mem, length, Options, StringRef(path));
   if (!M)
     return nullptr;
   return wrap(M->release());
 }