include/llvm/IR/DiagnosticInfo.h - platform/prebuilts/clang/darwin-x86/sdk/3.5 - Git at Google

 //===- llvm/Support/DiagnosticInfo.h - Diagnostic Declaration ---*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the different classes involved in low level diagnostics.
 //
 // Diagnostics reporting is still done as part of the LLVMContext.
 //===----------------------------------------------------------------------===//

 #ifndef LLVM_SUPPORT_DIAGNOSTICINFO_H
 #define LLVM_SUPPORT_DIAGNOSTICINFO_H

 #include "llvm-c/Core.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/IR/DebugLoc.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_OptimizationFailure,
   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.
 /// The returned ID will be greater than or equal to DK_FirstPluginKind.
 /// Thus, the plugin identifiers will not conflict with the
 /// DiagnosticKind values.
 int getNextAvailablePluginDiagnosticKind();

 /// \brief This is the base abstract class for diagnostic reporting in
 /// the backend.
 /// The print method must be overloaded by the subclasses to print a
 /// user-friendly message in the client of the backend (let us call it a
 /// frontend).
 class DiagnosticInfo {
 private:
   /// Kind defines the kind of report this is about.
   const /* DiagnosticKind */ int Kind;
   /// Severity gives the severity of the diagnostic.
   const DiagnosticSeverity Severity;

 public:
   DiagnosticInfo(/* DiagnosticKind */ int Kind, DiagnosticSeverity Severity)
       : Kind(Kind), Severity(Severity) {}

   virtual ~DiagnosticInfo() {}

   /* DiagnosticKind */ int getKind() const { return Kind; }
   DiagnosticSeverity getSeverity() const { return Severity; }

   /// Print using the given \p DP a user-friendly message.
   /// 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;
 };

 /// 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;
   /// Message to be reported.
   const Twine &MsgStr;
   /// Optional origin of the problem.
   const Instruction *Instr;

 public:
   /// \p MsgStr is the message to be reported to the frontend.
   /// This class does not copy \p MsgStr, therefore the reference must be valid
   /// for the whole life time of the Diagnostic.
   DiagnosticInfoInlineAsm(const Twine &MsgStr,
                           DiagnosticSeverity Severity = DS_Error)
       : DiagnosticInfo(DK_InlineAsm, Severity), LocCookie(0), MsgStr(MsgStr),
         Instr(nullptr) {}

   /// \p LocCookie if non-zero gives the line number for this report.
   /// \p MsgStr gives the message.
   /// This class does not copy \p MsgStr, therefore the reference must be valid
   /// for the whole life time of the Diagnostic.
   DiagnosticInfoInlineAsm(unsigned LocCookie, const Twine &MsgStr,
                           DiagnosticSeverity Severity = DS_Error)
       : DiagnosticInfo(DK_InlineAsm, Severity), LocCookie(LocCookie),
         MsgStr(MsgStr), Instr(nullptr) {}

   /// \p Instr gives the original instruction that triggered the diagnostic.
   /// \p MsgStr gives the message.
   /// This class does not copy \p MsgStr, therefore the reference must be valid
   /// for the whole life time of the Diagnostic.
   /// Same for \p I.
   DiagnosticInfoInlineAsm(const Instruction &I, const Twine &MsgStr,
                           DiagnosticSeverity Severity = DS_Error);

   unsigned getLocCookie() const { return LocCookie; }
   const Twine &getMsgStr() const { return MsgStr; }
   const Instruction *getInstruction() const { return Instr; }

   /// \see DiagnosticInfo::print.
   void print(DiagnosticPrinter &DP) const override;

   static bool classof(const DiagnosticInfo *DI) {
     return DI->getKind() == DK_InlineAsm;
   }
 };

 /// Diagnostic information for stack size reporting.
 /// This is basically a function and a size.
 class DiagnosticInfoStackSize : public DiagnosticInfo {
 private:
   /// The function that is concerned by this stack size diagnostic.
   const Function &Fn;
   /// The computed stack size.
   unsigned StackSize;

 public:
   /// \p The function that is concerned by this stack size diagnostic.
   /// \p The computed stack size.
   DiagnosticInfoStackSize(const Function &Fn, unsigned StackSize,
                           DiagnosticSeverity Severity = DS_Warning)
       : DiagnosticInfo(DK_StackSize, Severity), Fn(Fn), StackSize(StackSize) {}

   const Function &getFunction() const { return Fn; }
   unsigned getStackSize() const { return StackSize; }

   /// \see DiagnosticInfo::print.
   void print(DiagnosticPrinter &DP) const override;

   static bool classof(const DiagnosticInfo *DI) {
     return DI->getKind() == DK_StackSize;
   }
 };

 /// Diagnostic information for debug metadata version reporting.
 /// This is basically a module and a version.
 class DiagnosticInfoDebugMetadataVersion : public DiagnosticInfo {
 private:
   /// The module that is concerned by this debug metadata version diagnostic.
   const Module &M;
   /// The actual metadata version.
   unsigned MetadataVersion;

 public:
   /// \p The module that is concerned by this debug metadata version diagnostic.
   /// \p The actual metadata version.
   DiagnosticInfoDebugMetadataVersion(const Module &M, unsigned MetadataVersion,
                           DiagnosticSeverity Severity = DS_Warning)
       : DiagnosticInfo(DK_DebugMetadataVersion, Severity), M(M),
         MetadataVersion(MetadataVersion) {}

   const Module &getModule() const { return M; }
   unsigned getMetadataVersion() const { return MetadataVersion; }

   /// \see DiagnosticInfo::print.
   void print(DiagnosticPrinter &DP) const override;

   static bool classof(const DiagnosticInfo *DI) {
     return DI->getKind() == DK_DebugMetadataVersion;
   }
 };

 /// Diagnostic information for the sample profiler.
 class DiagnosticInfoSampleProfile : public DiagnosticInfo {
 public:
   DiagnosticInfoSampleProfile(const char *FileName, unsigned LineNum,
                               const Twine &Msg,
                               DiagnosticSeverity Severity = DS_Error)
       : DiagnosticInfo(DK_SampleProfile, Severity), FileName(FileName),
         LineNum(LineNum), Msg(Msg) {}
   DiagnosticInfoSampleProfile(const char *FileName, const Twine &Msg,
                               DiagnosticSeverity Severity = DS_Error)
       : DiagnosticInfo(DK_SampleProfile, Severity), FileName(FileName),
         LineNum(0), Msg(Msg) {}
   DiagnosticInfoSampleProfile(const Twine &Msg,
                               DiagnosticSeverity Severity = DS_Error)
       : DiagnosticInfo(DK_SampleProfile, Severity), FileName(nullptr),
         LineNum(0), Msg(Msg) {}

   /// \see DiagnosticInfo::print.
   void print(DiagnosticPrinter &DP) const override;

   static bool classof(const DiagnosticInfo *DI) {
     return DI->getKind() == DK_SampleProfile;
   }

   const char *getFileName() const { return FileName; }
   unsigned getLineNum() const { return LineNum; }
   const Twine &getMsg() const { return Msg; }

 private:
   /// Name of the input file associated with this diagnostic.
   const char *FileName;

   /// 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;
 };

 /// Common features for diagnostics dealing with optimization remarks.
 class DiagnosticInfoOptimizationBase : public DiagnosticInfo {
 public:
   /// \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.
   DiagnosticInfoOptimizationBase(enum DiagnosticKind Kind,
                                  enum DiagnosticSeverity Severity,
                                  const char *PassName, const Function &Fn,
                                  const DebugLoc &DLoc, const Twine &Msg)
       : DiagnosticInfo(Kind, Severity), PassName(PassName), Fn(Fn), DLoc(DLoc),
         Msg(Msg) {}

   /// \see DiagnosticInfo::print.
   void print(DiagnosticPrinter &DP) const override;

   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).
   virtual bool isEnabled() 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;

   /// Return location information for this diagnostic in three parts:
   /// the source file name, line number and column.
   void getLocation(StringRef *Filename, unsigned *Line, unsigned *Column) 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.
   DebugLoc DLoc;

   /// Message to report.
   const Twine &Msg;
 };

 /// Diagnostic information for applied optimization remarks.
 class DiagnosticInfoOptimizationRemark : public DiagnosticInfoOptimizationBase {
 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)
       : DiagnosticInfoOptimizationBase(DK_OptimizationRemark, DS_Remark,
                                        PassName, Fn, DLoc, Msg) {}

   static bool classof(const DiagnosticInfo *DI) {
     return DI->getKind() == DK_OptimizationRemark;
   }

   /// \see DiagnosticInfoOptimizationBase::isEnabled.
   virtual bool isEnabled() const override;
 };

 /// Diagnostic information for missed-optimization remarks.
 class DiagnosticInfoOptimizationRemarkMissed
     : public DiagnosticInfoOptimizationBase {
 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)
       : DiagnosticInfoOptimizationBase(DK_OptimizationRemarkMissed, DS_Remark,
                                        PassName, Fn, DLoc, Msg) {}

   static bool classof(const DiagnosticInfo *DI) {
     return DI->getKind() == DK_OptimizationRemarkMissed;
   }

   /// \see DiagnosticInfoOptimizationBase::isEnabled.
   virtual bool isEnabled() const override;
 };

 /// Diagnostic information for optimization analysis remarks.
 class DiagnosticInfoOptimizationRemarkAnalysis
     : public DiagnosticInfoOptimizationBase {
 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)
       : DiagnosticInfoOptimizationBase(DK_OptimizationRemarkAnalysis, DS_Remark,
                                        PassName, Fn, DLoc, Msg) {}

   static bool classof(const DiagnosticInfo *DI) {
     return DI->getKind() == DK_OptimizationRemarkAnalysis;
   }

   /// \see DiagnosticInfoOptimizationBase::isEnabled.
   virtual bool isEnabled() const override;
 };

 // Create wrappers for C Binding types (see CBindingWrapping.h).
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(DiagnosticInfo, LLVMDiagnosticInfoRef)

 /// 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(LLVMContext &Ctx, 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(LLVMContext &Ctx, 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(LLVMContext &Ctx, const char *PassName,
                                     const Function &Fn, const DebugLoc &DLoc,
                                     const Twine &Msg);

 /// Diagnostic information for optimization failures.
 class DiagnosticInfoOptimizationFailure
     : public DiagnosticInfoOptimizationBase {
 public:
   /// \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.
   DiagnosticInfoOptimizationFailure(const Function &Fn, const DebugLoc &DLoc,
                                     const Twine &Msg)
       : DiagnosticInfoOptimizationBase(DK_OptimizationFailure, DS_Warning,
                                        nullptr, Fn, DLoc, Msg) {}

   static bool classof(const DiagnosticInfo *DI) {
     return DI->getKind() == DK_OptimizationFailure;
   }

   /// \see DiagnosticInfoOptimizationBase::isEnabled.
   virtual bool isEnabled() const override;
 };

 /// Emit a warning when loop vectorization is specified but fails. \p Fn is the
 /// function triggering the warning, \p DLoc is the debug location where the
 /// diagnostic is generated. \p Msg is the message string to use.
 void emitLoopVectorizeWarning(LLVMContext &Ctx, const Function &Fn,
                               const DebugLoc &DLoc, const Twine &Msg);

 /// Emit a warning when loop interleaving is specified but fails. \p Fn is the
 /// function triggering the warning, \p DLoc is the debug location where the
 /// diagnostic is generated. \p Msg is the message string to use.
 void emitLoopInterleaveWarning(LLVMContext &Ctx, const Function &Fn,
                                const DebugLoc &DLoc, const Twine &Msg);

 } // End namespace llvm

 #endif
	//===- llvm/Support/DiagnosticInfo.h - Diagnostic Declaration ---- C++ --===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//
	//
	// This file declares the different classes involved in low level diagnostics.
	//
	// Diagnostics reporting is still done as part of the LLVMContext.
	//===----------------------------------------------------------------------===//

	#ifndef LLVM_SUPPORT_DIAGNOSTICINFO_H
	#define LLVM_SUPPORT_DIAGNOSTICINFO_H

	#include "llvm-c/Core.h"
	#include "llvm/ADT/ArrayRef.h"
	#include "llvm/IR/DebugLoc.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_OptimizationFailure,
	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.
	/// The returned ID will be greater than or equal to DK_FirstPluginKind.
	/// Thus, the plugin identifiers will not conflict with the
	/// DiagnosticKind values.
	int getNextAvailablePluginDiagnosticKind();

	/// \brief This is the base abstract class for diagnostic reporting in
	/// the backend.
	/// The print method must be overloaded by the subclasses to print a
	/// user-friendly message in the client of the backend (let us call it a
	/// frontend).
	class DiagnosticInfo {
	private:
	/// Kind defines the kind of report this is about.
	const /* DiagnosticKind */ int Kind;
	/// Severity gives the severity of the diagnostic.
	const DiagnosticSeverity Severity;

	public:
	DiagnosticInfo(/* DiagnosticKind */ int Kind, DiagnosticSeverity Severity)
	: Kind(Kind), Severity(Severity) {}

	virtual ~DiagnosticInfo() {}

	/* DiagnosticKind */ int getKind() const { return Kind; }
	DiagnosticSeverity getSeverity() const { return Severity; }

	/// Print using the given \p DP a user-friendly message.
	/// 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;
	};

	/// 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;
	/// Message to be reported.
	const Twine &MsgStr;
	/// Optional origin of the problem.
	const Instruction *Instr;

	public:
	/// \p MsgStr is the message to be reported to the frontend.
	/// This class does not copy \p MsgStr, therefore the reference must be valid
	/// for the whole life time of the Diagnostic.
	DiagnosticInfoInlineAsm(const Twine &MsgStr,
	DiagnosticSeverity Severity = DS_Error)
	: DiagnosticInfo(DK_InlineAsm, Severity), LocCookie(0), MsgStr(MsgStr),
	Instr(nullptr) {}

	/// \p LocCookie if non-zero gives the line number for this report.
	/// \p MsgStr gives the message.
	/// This class does not copy \p MsgStr, therefore the reference must be valid
	/// for the whole life time of the Diagnostic.
	DiagnosticInfoInlineAsm(unsigned LocCookie, const Twine &MsgStr,
	DiagnosticSeverity Severity = DS_Error)
	: DiagnosticInfo(DK_InlineAsm, Severity), LocCookie(LocCookie),
	MsgStr(MsgStr), Instr(nullptr) {}

	/// \p Instr gives the original instruction that triggered the diagnostic.
	/// \p MsgStr gives the message.
	/// This class does not copy \p MsgStr, therefore the reference must be valid
	/// for the whole life time of the Diagnostic.
	/// Same for \p I.
	DiagnosticInfoInlineAsm(const Instruction &I, const Twine &MsgStr,
	DiagnosticSeverity Severity = DS_Error);

	unsigned getLocCookie() const { return LocCookie; }
	const Twine &getMsgStr() const { return MsgStr; }
	const Instruction *getInstruction() const { return Instr; }

	/// \see DiagnosticInfo::print.
	void print(DiagnosticPrinter &DP) const override;

	static bool classof(const DiagnosticInfo *DI) {
	return DI->getKind() == DK_InlineAsm;
	}
	};

	/// Diagnostic information for stack size reporting.
	/// This is basically a function and a size.
	class DiagnosticInfoStackSize : public DiagnosticInfo {
	private:
	/// The function that is concerned by this stack size diagnostic.
	const Function &Fn;
	/// The computed stack size.
	unsigned StackSize;

	public:
	/// \p The function that is concerned by this stack size diagnostic.
	/// \p The computed stack size.
	DiagnosticInfoStackSize(const Function &Fn, unsigned StackSize,
	DiagnosticSeverity Severity = DS_Warning)
	: DiagnosticInfo(DK_StackSize, Severity), Fn(Fn), StackSize(StackSize) {}

	const Function &getFunction() const { return Fn; }
	unsigned getStackSize() const { return StackSize; }

	/// \see DiagnosticInfo::print.
	void print(DiagnosticPrinter &DP) const override;

	static bool classof(const DiagnosticInfo *DI) {
	return DI->getKind() == DK_StackSize;
	}
	};

	/// Diagnostic information for debug metadata version reporting.
	/// This is basically a module and a version.
	class DiagnosticInfoDebugMetadataVersion : public DiagnosticInfo {
	private:
	/// The module that is concerned by this debug metadata version diagnostic.
	const Module &M;
	/// The actual metadata version.
	unsigned MetadataVersion;

	public:
	/// \p The module that is concerned by this debug metadata version diagnostic.
	/// \p The actual metadata version.
	DiagnosticInfoDebugMetadataVersion(const Module &M, unsigned MetadataVersion,
	DiagnosticSeverity Severity = DS_Warning)
	: DiagnosticInfo(DK_DebugMetadataVersion, Severity), M(M),
	MetadataVersion(MetadataVersion) {}

	const Module &getModule() const { return M; }
	unsigned getMetadataVersion() const { return MetadataVersion; }

	/// \see DiagnosticInfo::print.
	void print(DiagnosticPrinter &DP) const override;

	static bool classof(const DiagnosticInfo *DI) {
	return DI->getKind() == DK_DebugMetadataVersion;
	}
	};

	/// Diagnostic information for the sample profiler.
	class DiagnosticInfoSampleProfile : public DiagnosticInfo {
	public:
	DiagnosticInfoSampleProfile(const char *FileName, unsigned LineNum,
	const Twine &Msg,
	DiagnosticSeverity Severity = DS_Error)
	: DiagnosticInfo(DK_SampleProfile, Severity), FileName(FileName),
	LineNum(LineNum), Msg(Msg) {}
	DiagnosticInfoSampleProfile(const char *FileName, const Twine &Msg,
	DiagnosticSeverity Severity = DS_Error)
	: DiagnosticInfo(DK_SampleProfile, Severity), FileName(FileName),
	LineNum(0), Msg(Msg) {}
	DiagnosticInfoSampleProfile(const Twine &Msg,
	DiagnosticSeverity Severity = DS_Error)
	: DiagnosticInfo(DK_SampleProfile, Severity), FileName(nullptr),
	LineNum(0), Msg(Msg) {}

	/// \see DiagnosticInfo::print.
	void print(DiagnosticPrinter &DP) const override;

	static bool classof(const DiagnosticInfo *DI) {
	return DI->getKind() == DK_SampleProfile;
	}

	const char *getFileName() const { return FileName; }
	unsigned getLineNum() const { return LineNum; }
	const Twine &getMsg() const { return Msg; }

	private:
	/// Name of the input file associated with this diagnostic.
	const char *FileName;

	/// 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;
	};

	/// Common features for diagnostics dealing with optimization remarks.
	class DiagnosticInfoOptimizationBase : public DiagnosticInfo {
	public:
	/// \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.
	DiagnosticInfoOptimizationBase(enum DiagnosticKind Kind,
	enum DiagnosticSeverity Severity,
	const char *PassName, const Function &Fn,
	const DebugLoc &DLoc, const Twine &Msg)
	: DiagnosticInfo(Kind, Severity), PassName(PassName), Fn(Fn), DLoc(DLoc),
	Msg(Msg) {}

	/// \see DiagnosticInfo::print.
	void print(DiagnosticPrinter &DP) const override;

	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).
	virtual bool isEnabled() 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;

	/// Return location information for this diagnostic in three parts:
	/// the source file name, line number and column.
	void getLocation(StringRef Filename, unsigned Line, unsigned *Column) 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.
	DebugLoc DLoc;

	/// Message to report.
	const Twine &Msg;
	};

	/// Diagnostic information for applied optimization remarks.
	class DiagnosticInfoOptimizationRemark : public DiagnosticInfoOptimizationBase {
	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)
	: DiagnosticInfoOptimizationBase(DK_OptimizationRemark, DS_Remark,
	PassName, Fn, DLoc, Msg) {}

	static bool classof(const DiagnosticInfo *DI) {
	return DI->getKind() == DK_OptimizationRemark;
	}

	/// \see DiagnosticInfoOptimizationBase::isEnabled.
	virtual bool isEnabled() const override;
	};

	/// Diagnostic information for missed-optimization remarks.
	class DiagnosticInfoOptimizationRemarkMissed
	: public DiagnosticInfoOptimizationBase {
	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)
	: DiagnosticInfoOptimizationBase(DK_OptimizationRemarkMissed, DS_Remark,
	PassName, Fn, DLoc, Msg) {}

	static bool classof(const DiagnosticInfo *DI) {
	return DI->getKind() == DK_OptimizationRemarkMissed;
	}

	/// \see DiagnosticInfoOptimizationBase::isEnabled.
	virtual bool isEnabled() const override;
	};

	/// Diagnostic information for optimization analysis remarks.
	class DiagnosticInfoOptimizationRemarkAnalysis
	: public DiagnosticInfoOptimizationBase {
	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)
	: DiagnosticInfoOptimizationBase(DK_OptimizationRemarkAnalysis, DS_Remark,
	PassName, Fn, DLoc, Msg) {}

	static bool classof(const DiagnosticInfo *DI) {
	return DI->getKind() == DK_OptimizationRemarkAnalysis;
	}

	/// \see DiagnosticInfoOptimizationBase::isEnabled.
	virtual bool isEnabled() const override;
	};

	// Create wrappers for C Binding types (see CBindingWrapping.h).
	DEFINE_SIMPLE_CONVERSION_FUNCTIONS(DiagnosticInfo, LLVMDiagnosticInfoRef)

	/// 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(LLVMContext &Ctx, 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(LLVMContext &Ctx, 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(LLVMContext &Ctx, const char *PassName,
	const Function &Fn, const DebugLoc &DLoc,
	const Twine &Msg);

	/// Diagnostic information for optimization failures.
	class DiagnosticInfoOptimizationFailure
	: public DiagnosticInfoOptimizationBase {
	public:
	/// \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.
	DiagnosticInfoOptimizationFailure(const Function &Fn, const DebugLoc &DLoc,
	const Twine &Msg)
	: DiagnosticInfoOptimizationBase(DK_OptimizationFailure, DS_Warning,
	nullptr, Fn, DLoc, Msg) {}

	static bool classof(const DiagnosticInfo *DI) {
	return DI->getKind() == DK_OptimizationFailure;
	}

	/// \see DiagnosticInfoOptimizationBase::isEnabled.
	virtual bool isEnabled() const override;
	};

	/// Emit a warning when loop vectorization is specified but fails. \p Fn is the
	/// function triggering the warning, \p DLoc is the debug location where the
	/// diagnostic is generated. \p Msg is the message string to use.
	void emitLoopVectorizeWarning(LLVMContext &Ctx, const Function &Fn,
	const DebugLoc &DLoc, const Twine &Msg);

	/// Emit a warning when loop interleaving is specified but fails. \p Fn is the
	/// function triggering the warning, \p DLoc is the debug location where the
	/// diagnostic is generated. \p Msg is the message string to use.
	void emitLoopInterleaveWarning(LLVMContext &Ctx, const Function &Fn,
	const DebugLoc &DLoc, const Twine &Msg);

	} // End namespace llvm

	#endif