LLVM  4.0.0
DiagnosticInfo.h
Go to the documentation of this file.
1 //===- llvm/IR/DiagnosticInfo.h - Diagnostic Declaration --------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file declares the different classes involved in low level diagnostics.
11 //
12 // Diagnostics reporting is still done as part of the LLVMContext.
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef LLVM_IR_DIAGNOSTICINFO_H
16 #define LLVM_IR_DIAGNOSTICINFO_H
17 
18 #include "llvm/ADT/None.h"
19 #include "llvm/ADT/Optional.h"
20 #include "llvm/ADT/SmallVector.h"
21 #include "llvm/ADT/StringRef.h"
22 #include "llvm/ADT/Twine.h"
23 #include "llvm/IR/DebugLoc.h"
26 #include "llvm-c/Types.h"
27 #include <functional>
28 #include <algorithm>
29 #include <cstdint>
30 #include <iterator>
31 #include <string>
32 
33 namespace llvm {
34 
35 // Forward declarations.
36 class DiagnosticPrinter;
37 class Function;
38 class Instruction;
39 class LLVMContext;
40 class Module;
41 class SMDiagnostic;
42 
43 /// \brief Defines the different supported severity of a diagnostic.
44 enum DiagnosticSeverity : char {
48  // A note attaches additional information to one of the previous diagnostic
49  // types.
51 };
52 
53 /// \brief Defines the different supported kind of a diagnostic.
54 /// This enum should be extended with a new ID for each added concrete subclass.
76 };
77 
78 /// \brief Get the next available kind ID for a plugin diagnostic.
79 /// Each time this function is called, it returns a different number.
80 /// Therefore, a plugin that wants to "identify" its own classes
81 /// with a dynamic identifier, just have to use this method to get a new ID
82 /// and assign it to each of its classes.
83 /// The returned ID will be greater than or equal to DK_FirstPluginKind.
84 /// Thus, the plugin identifiers will not conflict with the
85 /// DiagnosticKind values.
87 
88 /// \brief This is the base abstract class for diagnostic reporting in
89 /// the backend.
90 /// The print method must be overloaded by the subclasses to print a
91 /// user-friendly message in the client of the backend (let us call it a
92 /// frontend).
94 private:
95  /// Kind defines the kind of report this is about.
96  const /* DiagnosticKind */ int Kind;
97  /// Severity gives the severity of the diagnostic.
98  const DiagnosticSeverity Severity;
99 
100 public:
101  DiagnosticInfo(/* DiagnosticKind */ int Kind, DiagnosticSeverity Severity)
102  : Kind(Kind), Severity(Severity) {}
103 
104  virtual ~DiagnosticInfo() = default;
105 
106  /* DiagnosticKind */ int getKind() const { return Kind; }
107  DiagnosticSeverity getSeverity() const { return Severity; }
108 
109  /// Print using the given \p DP a user-friendly message.
110  /// This is the default message that will be printed to the user.
111  /// It is used when the frontend does not directly take advantage
112  /// of the information contained in fields of the subclasses.
113  /// The printed message must not end with '.' nor start with a severity
114  /// keyword.
115  virtual void print(DiagnosticPrinter &DP) const = 0;
116 };
117 
118 typedef std::function<void(const DiagnosticInfo &)> DiagnosticHandlerFunction;
119 
120 /// Diagnostic information for inline asm reporting.
121 /// This is basically a message and an optional location.
123 private:
124  /// Optional line information. 0 if not set.
125  unsigned LocCookie;
126  /// Message to be reported.
127  const Twine &MsgStr;
128  /// Optional origin of the problem.
129  const Instruction *Instr;
130 
131 public:
132  /// \p MsgStr is the message to be reported to the frontend.
133  /// This class does not copy \p MsgStr, therefore the reference must be valid
134  /// for the whole life time of the Diagnostic.
136  DiagnosticSeverity Severity = DS_Error)
137  : DiagnosticInfo(DK_InlineAsm, Severity), LocCookie(0), MsgStr(MsgStr),
138  Instr(nullptr) {}
139 
140  /// \p LocCookie if non-zero gives the line number for this report.
141  /// \p MsgStr gives the message.
142  /// This class does not copy \p MsgStr, therefore the reference must be valid
143  /// for the whole life time of the Diagnostic.
144  DiagnosticInfoInlineAsm(unsigned LocCookie, const Twine &MsgStr,
145  DiagnosticSeverity Severity = DS_Error)
146  : DiagnosticInfo(DK_InlineAsm, Severity), LocCookie(LocCookie),
147  MsgStr(MsgStr), Instr(nullptr) {}
148 
149  /// \p Instr gives the original instruction that triggered the diagnostic.
150  /// \p MsgStr gives the message.
151  /// This class does not copy \p MsgStr, therefore the reference must be valid
152  /// for the whole life time of the Diagnostic.
153  /// Same for \p I.
154  DiagnosticInfoInlineAsm(const Instruction &I, const Twine &MsgStr,
155  DiagnosticSeverity Severity = DS_Error);
156 
157  unsigned getLocCookie() const { return LocCookie; }
158  const Twine &getMsgStr() const { return MsgStr; }
159  const Instruction *getInstruction() const { return Instr; }
160 
161  /// \see DiagnosticInfo::print.
162  void print(DiagnosticPrinter &DP) const override;
163 
164  static bool classof(const DiagnosticInfo *DI) {
165  return DI->getKind() == DK_InlineAsm;
166  }
167 };
168 
169 /// Diagnostic information for stack size etc. reporting.
170 /// This is basically a function and a size.
172 private:
173  /// The function that is concerned by this resource limit diagnostic.
174  const Function &Fn;
175 
176  /// Description of the resource type (e.g. stack size)
177  const char *ResourceName;
178 
179  /// The computed size usage
180  uint64_t ResourceSize;
181 
182  // Threshould passed
183  uint64_t ResourceLimit;
184 
185 public:
186  /// \p The function that is concerned by this stack size diagnostic.
187  /// \p The computed stack size.
189  const char *ResourceName,
190  uint64_t ResourceSize,
191  DiagnosticSeverity Severity = DS_Warning,
193  uint64_t ResourceLimit = 0)
194  : DiagnosticInfo(Kind, Severity),
195  Fn(Fn),
196  ResourceName(ResourceName),
197  ResourceSize(ResourceSize),
198  ResourceLimit(ResourceLimit) {}
199 
200  const Function &getFunction() const { return Fn; }
201  const char *getResourceName() const { return ResourceName; }
202  uint64_t getResourceSize() const { return ResourceSize; }
203  uint64_t getResourceLimit() const { return ResourceLimit; }
204 
205  /// \see DiagnosticInfo::print.
206  void print(DiagnosticPrinter &DP) const override;
207 
208  static bool classof(const DiagnosticInfo *DI) {
209  return DI->getKind() == DK_ResourceLimit ||
210  DI->getKind() == DK_StackSize;
211  }
212 };
213 
215 public:
217  uint64_t StackSize,
218  DiagnosticSeverity Severity = DS_Warning,
219  uint64_t StackLimit = 0)
220  : DiagnosticInfoResourceLimit(Fn, "stack size", StackSize,
221  Severity, DK_StackSize, StackLimit) {}
222 
223  uint64_t getStackSize() const { return getResourceSize(); }
224  uint64_t getStackLimit() const { return getResourceLimit(); }
225 
226  static bool classof(const DiagnosticInfo *DI) {
227  return DI->getKind() == DK_StackSize;
228  }
229 };
230 
231 /// Diagnostic information for debug metadata version reporting.
232 /// This is basically a module and a version.
234 private:
235  /// The module that is concerned by this debug metadata version diagnostic.
236  const Module &M;
237  /// The actual metadata version.
238  unsigned MetadataVersion;
239 
240 public:
241  /// \p The module that is concerned by this debug metadata version diagnostic.
242  /// \p The actual metadata version.
243  DiagnosticInfoDebugMetadataVersion(const Module &M, unsigned MetadataVersion,
244  DiagnosticSeverity Severity = DS_Warning)
245  : DiagnosticInfo(DK_DebugMetadataVersion, Severity), M(M),
246  MetadataVersion(MetadataVersion) {}
247 
248  const Module &getModule() const { return M; }
249  unsigned getMetadataVersion() const { return MetadataVersion; }
250 
251  /// \see DiagnosticInfo::print.
252  void print(DiagnosticPrinter &DP) const override;
253 
254  static bool classof(const DiagnosticInfo *DI) {
255  return DI->getKind() == DK_DebugMetadataVersion;
256  }
257 };
258 
259 /// Diagnostic information for stripping invalid debug metadata.
261 private:
262  /// The module that is concerned by this debug metadata version diagnostic.
263  const Module &M;
264 
265 public:
266  /// \p The module that is concerned by this debug metadata version diagnostic.
268  const Module &M, DiagnosticSeverity Severity = DS_Warning)
269  : DiagnosticInfo(DK_DebugMetadataVersion, Severity), M(M) {}
270 
271  const Module &getModule() const { return M; }
272 
273  /// \see DiagnosticInfo::print.
274  void print(DiagnosticPrinter &DP) const override;
275 
276  static bool classof(const DiagnosticInfo *DI) {
277  return DI->getKind() == DK_DebugMetadataInvalid;
278  }
279 };
280 
281 /// Diagnostic information for the sample profiler.
283 public:
284  DiagnosticInfoSampleProfile(StringRef FileName, unsigned LineNum,
285  const Twine &Msg,
286  DiagnosticSeverity Severity = DS_Error)
287  : DiagnosticInfo(DK_SampleProfile, Severity), FileName(FileName),
288  LineNum(LineNum), Msg(Msg) {}
290  DiagnosticSeverity Severity = DS_Error)
291  : DiagnosticInfo(DK_SampleProfile, Severity), FileName(FileName),
292  LineNum(0), Msg(Msg) {}
294  DiagnosticSeverity Severity = DS_Error)
295  : DiagnosticInfo(DK_SampleProfile, Severity), LineNum(0), Msg(Msg) {}
296 
297  /// \see DiagnosticInfo::print.
298  void print(DiagnosticPrinter &DP) const override;
299 
300  static bool classof(const DiagnosticInfo *DI) {
301  return DI->getKind() == DK_SampleProfile;
302  }
303 
304  StringRef getFileName() const { return FileName; }
305  unsigned getLineNum() const { return LineNum; }
306  const Twine &getMsg() const { return Msg; }
307 
308 private:
309  /// Name of the input file associated with this diagnostic.
310  StringRef FileName;
311 
312  /// Line number where the diagnostic occurred. If 0, no line number will
313  /// be emitted in the message.
314  unsigned LineNum;
315 
316  /// Message to report.
317  const Twine &Msg;
318 };
319 
320 /// Diagnostic information for the PGO profiler.
322 public:
323  DiagnosticInfoPGOProfile(const char *FileName, const Twine &Msg,
324  DiagnosticSeverity Severity = DS_Error)
325  : DiagnosticInfo(DK_PGOProfile, Severity), FileName(FileName), Msg(Msg) {}
326 
327  /// \see DiagnosticInfo::print.
328  void print(DiagnosticPrinter &DP) const override;
329 
330  static bool classof(const DiagnosticInfo *DI) {
331  return DI->getKind() == DK_PGOProfile;
332  }
333 
334  const char *getFileName() const { return FileName; }
335  const Twine &getMsg() const { return Msg; }
336 
337 private:
338  /// Name of the input file associated with this diagnostic.
339  const char *FileName;
340 
341  /// Message to report.
342  const Twine &Msg;
343 };
344 
345 /// Common features for diagnostics with an associated DebugLoc
347 public:
348  /// \p Fn is the function where the diagnostic is being emitted. \p DLoc is
349  /// the location information to use in the diagnostic.
351  enum DiagnosticSeverity Severity,
352  const Function &Fn,
353  const DebugLoc &DLoc)
354  : DiagnosticInfo(Kind, Severity), Fn(Fn), DLoc(DLoc) {}
355 
356  /// Return true if location information is available for this diagnostic.
357  bool isLocationAvailable() const;
358 
359  /// Return a string with the location information for this diagnostic
360  /// in the format "file:line:col". If location information is not available,
361  /// it returns "<unknown>:0:0".
362  const std::string getLocationStr() const;
363 
364  /// Return location information for this diagnostic in three parts:
365  /// the source file name, line number and column.
366  void getLocation(StringRef *Filename, unsigned *Line, unsigned *Column) const;
367 
368  const Function &getFunction() const { return Fn; }
369  const DebugLoc &getDebugLoc() const { return DLoc; }
370 
371 private:
372  /// Function where this diagnostic is triggered.
373  const Function &Fn;
374 
375  /// Debug location where this diagnostic is triggered.
376  DebugLoc DLoc;
377 };
378 
379 /// Common features for diagnostics dealing with optimization remarks.
381 public:
382  /// \brief Used to set IsVerbose via the stream interface.
383  struct setIsVerbose {};
384 
385  /// \brief When an instance of this is inserted into the stream, the arguments
386  /// following will not appear in the remark printed in the compiler output
387  /// (-Rpass) but only in the optimization record file
388  /// (-fsave-optimization-record).
389  struct setExtraArgs {};
390 
391  /// \brief Used in the streaming interface as the general argument type. It
392  /// internally converts everything into a key-value pair.
393  struct Argument {
395  std::string Val;
396  // If set, the debug location corresponding to the value.
398 
399  explicit Argument(StringRef Str = "") : Key("String"), Val(Str) {}
402  Argument(StringRef Key, int N);
403  Argument(StringRef Key, unsigned N);
404  Argument(StringRef Key, bool B) : Key(Key), Val(B ? "true" : "false") {}
405  };
406 
407  /// \p PassName is the name of the pass emitting this diagnostic. \p
408  /// RemarkName is a textual identifier for the remark. \p Fn is the function
409  /// where the diagnostic is being emitted. \p DLoc is the location information
410  /// to use in the diagnostic. If line table information is available, the
411  /// diagnostic will include the source code location. \p CodeRegion is IR
412  /// value (currently basic block) that the optimization operates on. This is
413  /// currently used to provide run-time hotness information with PGO.
415  enum DiagnosticSeverity Severity,
416  const char *PassName, StringRef RemarkName,
417  const Function &Fn, const DebugLoc &DLoc,
418  Value *CodeRegion = nullptr)
419  : DiagnosticInfoWithDebugLocBase(Kind, Severity, Fn, DLoc),
420  PassName(PassName), RemarkName(RemarkName), CodeRegion(CodeRegion) {}
421 
422  /// \brief This is ctor variant allows a pass to build an optimization remark
423  /// from an existing remark.
424  ///
425  /// This is useful when a transformation pass (e.g LV) wants to emit a remark
426  /// (\p Orig) generated by one of its analyses (e.g. LAA) as its own analysis
427  /// remark. The string \p Prepend will be emitted before the original
428  /// message.
429  DiagnosticInfoOptimizationBase(const char *PassName, StringRef Prepend,
430  const DiagnosticInfoOptimizationBase &Orig)
432  Orig.getSeverity(), Orig.getFunction(),
433  Orig.getDebugLoc()),
434  PassName(PassName), RemarkName(Orig.RemarkName),
435  CodeRegion(Orig.getCodeRegion()) {
436  *this << Prepend;
437  std::copy(Orig.Args.begin(), Orig.Args.end(), std::back_inserter(Args));
438  }
439 
440  /// Legacy interface.
441  /// \p PassName is the name of the pass emitting this diagnostic.
442  /// \p Fn is the function where the diagnostic is being emitted. \p DLoc is
443  /// the location information to use in the diagnostic. If line table
444  /// information is available, the diagnostic will include the source code
445  /// location. \p Msg is the message to show. Note that this class does not
446  /// copy this message, so this reference must be valid for the whole life time
447  /// of the diagnostic.
449  enum DiagnosticSeverity Severity,
450  const char *PassName, const Function &Fn,
451  const DebugLoc &DLoc, const Twine &Msg,
452  Optional<uint64_t> Hotness = None)
453  : DiagnosticInfoWithDebugLocBase(Kind, Severity, Fn, DLoc),
454  PassName(PassName), Hotness(Hotness) {
455  Args.push_back(Argument(Msg.str()));
456  }
457 
462 
463  /// \see DiagnosticInfo::print.
464  void print(DiagnosticPrinter &DP) const override;
465 
466  /// Return true if this optimization remark is enabled by one of
467  /// of the LLVM command line flags (-pass-remarks, -pass-remarks-missed,
468  /// or -pass-remarks-analysis). Note that this only handles the LLVM
469  /// flags. We cannot access Clang flags from here (they are handled
470  /// in BackendConsumer::OptimizationRemarkHandler).
471  virtual bool isEnabled() const = 0;
472 
473  StringRef getPassName() const { return PassName; }
474  std::string getMsg() const;
475  Optional<uint64_t> getHotness() const { return Hotness; }
476  void setHotness(Optional<uint64_t> H) { Hotness = H; }
477 
478  Value *getCodeRegion() const { return CodeRegion; }
479 
480  bool isVerbose() const { return IsVerbose; }
481 
482  static bool classof(const DiagnosticInfo *DI) {
483  return DI->getKind() >= DK_FirstRemark &&
484  DI->getKind() <= DK_LastRemark;
485  }
486 
487 private:
488  /// Name of the pass that triggers this report. If this matches the
489  /// regular expression given in -Rpass=regexp, then the remark will
490  /// be emitted.
491  const char *PassName;
492 
493  /// Textual identifier for the remark. Can be used by external tools reading
494  /// the YAML output file for optimization remarks to identify the remark.
495  StringRef RemarkName;
496 
497  /// If profile information is available, this is the number of times the
498  /// corresponding code was executed in a profile instrumentation run.
499  Optional<uint64_t> Hotness;
500 
501  /// The IR value (currently basic block) that the optimization operates on.
502  /// This is currently used to provide run-time hotness information with PGO.
503  Value *CodeRegion;
504 
505  /// Arguments collected via the streaming interface.
507 
508  /// The remark is expected to be noisy.
509  bool IsVerbose = false;
510 
511  /// \brief If positive, the index of the first argument that only appear in
512  /// the optimization records and not in the remark printed in the compiler
513  /// output.
514  int FirstExtraArgIndex = -1;
515 
517 };
518 
519 /// Diagnostic information for applied optimization remarks.
521 public:
522  /// \p PassName is the name of the pass emitting this diagnostic. If
523  /// this name matches the regular expression given in -Rpass=, then the
524  /// diagnostic will be emitted. \p Fn is the function where the diagnostic
525  /// is being emitted. \p DLoc is the location information to use in the
526  /// diagnostic. If line table information is available, the diagnostic
527  /// will include the source code location. \p Msg is the message to show.
528  /// Note that this class does not copy this message, so this reference
529  /// must be valid for the whole life time of the diagnostic.
530  OptimizationRemark(const char *PassName, const Function &Fn,
531  const DebugLoc &DLoc, const Twine &Msg,
532  Optional<uint64_t> Hotness = None)
534  PassName, Fn, DLoc, Msg, Hotness) {}
535 
536  /// \p PassName is the name of the pass emitting this diagnostic. If this name
537  /// matches the regular expression given in -Rpass=, then the diagnostic will
538  /// be emitted. \p RemarkName is a textual identifier for the remark. \p
539  /// DLoc is the debug location and \p CodeRegion is the region that the
540  /// optimization operates on (currently on block is supported).
541  OptimizationRemark(const char *PassName, StringRef RemarkName,
542  const DebugLoc &DLoc, Value *CodeRegion);
543 
544  /// Same as above but the debug location and code region is derived from \p
545  /// Instr.
546  OptimizationRemark(const char *PassName, StringRef RemarkName,
547  Instruction *Inst);
548 
549  static bool classof(const DiagnosticInfo *DI) {
550  return DI->getKind() == DK_OptimizationRemark;
551  }
552 
553  /// \see DiagnosticInfoOptimizationBase::isEnabled.
554  bool isEnabled() const override;
555 };
556 
557 /// Diagnostic information for missed-optimization remarks.
559 public:
560  /// \p PassName is the name of the pass emitting this diagnostic. If
561  /// this name matches the regular expression given in -Rpass-missed=, then the
562  /// diagnostic will be emitted. \p Fn is the function where the diagnostic
563  /// is being emitted. \p DLoc is the location information to use in the
564  /// diagnostic. If line table information is available, the diagnostic
565  /// will include the source code location. \p Msg is the message to show.
566  /// Note that this class does not copy this message, so this reference
567  /// must be valid for the whole life time of the diagnostic.
568  OptimizationRemarkMissed(const char *PassName, const Function &Fn,
569  const DebugLoc &DLoc, const Twine &Msg,
570  Optional<uint64_t> Hotness = None)
572  PassName, Fn, DLoc, Msg, Hotness) {}
573 
574  /// \p PassName is the name of the pass emitting this diagnostic. If this name
575  /// matches the regular expression given in -Rpass-missed=, then the
576  /// diagnostic will be emitted. \p RemarkName is a textual identifier for the
577  /// remark. \p DLoc is the debug location and \p CodeRegion is the region
578  /// that the optimization operates on (currently on block is supported).
579  OptimizationRemarkMissed(const char *PassName, StringRef RemarkName,
580  const DebugLoc &DLoc, Value *CodeRegion);
581 
582  /// \brief Same as above but \p Inst is used to derive code region and debug
583  /// location.
584  OptimizationRemarkMissed(const char *PassName, StringRef RemarkName,
585  Instruction *Inst);
586 
587  static bool classof(const DiagnosticInfo *DI) {
588  return DI->getKind() == DK_OptimizationRemarkMissed;
589  }
590 
591  /// \see DiagnosticInfoOptimizationBase::isEnabled.
592  bool isEnabled() const override;
593 };
594 
595 /// Diagnostic information for optimization analysis remarks.
597 public:
598  /// \p PassName is the name of the pass emitting this diagnostic. If
599  /// this name matches the regular expression given in -Rpass-analysis=, then
600  /// the diagnostic will be emitted. \p Fn is the function where the diagnostic
601  /// is being emitted. \p DLoc is the location information to use in the
602  /// diagnostic. If line table information is available, the diagnostic will
603  /// include the source code location. \p Msg is the message to show. Note that
604  /// this class does not copy this message, so this reference must be valid for
605  /// the whole life time of the diagnostic.
606  OptimizationRemarkAnalysis(const char *PassName, const Function &Fn,
607  const DebugLoc &DLoc, const Twine &Msg,
608  Optional<uint64_t> Hotness = None)
610  PassName, Fn, DLoc, Msg, Hotness) {}
611 
612  /// \p PassName is the name of the pass emitting this diagnostic. If this name
613  /// matches the regular expression given in -Rpass-analysis=, then the
614  /// diagnostic will be emitted. \p RemarkName is a textual identifier for the
615  /// remark. \p DLoc is the debug location and \p CodeRegion is the region
616  /// that the optimization operates on (currently on block is supported).
617  OptimizationRemarkAnalysis(const char *PassName, StringRef RemarkName,
618  const DebugLoc &DLoc, Value *CodeRegion);
619 
620  /// \brief This is ctor variant allows a pass to build an optimization remark
621  /// from an existing remark.
622  ///
623  /// This is useful when a transformation pass (e.g LV) wants to emit a remark
624  /// (\p Orig) generated by one of its analyses (e.g. LAA) as its own analysis
625  /// remark. The string \p Prepend will be emitted before the original
626  /// message.
627  OptimizationRemarkAnalysis(const char *PassName, StringRef Prepend,
628  const OptimizationRemarkAnalysis &Orig)
629  : DiagnosticInfoOptimizationBase(PassName, Prepend, Orig) {}
630 
631  /// \brief Same as above but \p Inst is used to derive code region and debug
632  /// location.
633  OptimizationRemarkAnalysis(const char *PassName, StringRef RemarkName,
634  Instruction *Inst);
635 
636  static bool classof(const DiagnosticInfo *DI) {
637  return DI->getKind() == DK_OptimizationRemarkAnalysis;
638  }
639 
640  /// \see DiagnosticInfoOptimizationBase::isEnabled.
641  bool isEnabled() const override;
642 
643  static const char *AlwaysPrint;
644 
645  bool shouldAlwaysPrint() const { return getPassName() == AlwaysPrint; }
646 
647 protected:
648  OptimizationRemarkAnalysis(enum DiagnosticKind Kind, const char *PassName,
649  const Function &Fn, const DebugLoc &DLoc,
650  const Twine &Msg, Optional<uint64_t> Hotness)
651  : DiagnosticInfoOptimizationBase(Kind, DS_Remark, PassName, Fn, DLoc, Msg,
652  Hotness) {}
653 
654  OptimizationRemarkAnalysis(enum DiagnosticKind Kind, const char *PassName,
655  StringRef RemarkName, const DebugLoc &DLoc,
656  Value *CodeRegion);
657 };
658 
659 /// Diagnostic information for optimization analysis remarks related to
660 /// floating-point non-commutativity.
662 public:
663  /// \p PassName is the name of the pass emitting this diagnostic. If
664  /// this name matches the regular expression given in -Rpass-analysis=, then
665  /// the diagnostic will be emitted. \p Fn is the function where the diagnostic
666  /// is being emitted. \p DLoc is the location information to use in the
667  /// diagnostic. If line table information is available, the diagnostic will
668  /// include the source code location. \p Msg is the message to show. The
669  /// front-end will append its own message related to options that address
670  /// floating-point non-commutativity. Note that this class does not copy this
671  /// message, so this reference must be valid for the whole life time of the
672  /// diagnostic.
673  OptimizationRemarkAnalysisFPCommute(const char *PassName, const Function &Fn,
674  const DebugLoc &DLoc, const Twine &Msg,
675  Optional<uint64_t> Hotness = None)
677  PassName, Fn, DLoc, Msg, Hotness) {}
678 
679  /// \p PassName is the name of the pass emitting this diagnostic. If this name
680  /// matches the regular expression given in -Rpass-analysis=, then the
681  /// diagnostic will be emitted. \p RemarkName is a textual identifier for the
682  /// remark. \p DLoc is the debug location and \p CodeRegion is the region
683  /// that the optimization operates on (currently on block is supported). The
684  /// front-end will append its own message related to options that address
685  /// floating-point non-commutativity.
687  StringRef RemarkName,
688  const DebugLoc &DLoc, Value *CodeRegion)
690  PassName, RemarkName, DLoc, CodeRegion) {}
691 
692  static bool classof(const DiagnosticInfo *DI) {
694  }
695 };
696 
697 /// Diagnostic information for optimization analysis remarks related to
698 /// pointer aliasing.
700 public:
701  /// \p PassName is the name of the pass emitting this diagnostic. If
702  /// this name matches the regular expression given in -Rpass-analysis=, then
703  /// the diagnostic will be emitted. \p Fn is the function where the diagnostic
704  /// is being emitted. \p DLoc is the location information to use in the
705  /// diagnostic. If line table information is available, the diagnostic will
706  /// include the source code location. \p Msg is the message to show. The
707  /// front-end will append its own message related to options that address
708  /// pointer aliasing legality. Note that this class does not copy this
709  /// message, so this reference must be valid for the whole life time of the
710  /// diagnostic.
711  OptimizationRemarkAnalysisAliasing(const char *PassName, const Function &Fn,
712  const DebugLoc &DLoc, const Twine &Msg,
713  Optional<uint64_t> Hotness = None)
715  PassName, Fn, DLoc, Msg, Hotness) {}
716 
717  /// \p PassName is the name of the pass emitting this diagnostic. If this name
718  /// matches the regular expression given in -Rpass-analysis=, then the
719  /// diagnostic will be emitted. \p RemarkName is a textual identifier for the
720  /// remark. \p DLoc is the debug location and \p CodeRegion is the region
721  /// that the optimization operates on (currently on block is supported). The
722  /// front-end will append its own message related to options that address
723  /// pointer aliasing legality.
724  OptimizationRemarkAnalysisAliasing(const char *PassName, StringRef RemarkName,
725  const DebugLoc &DLoc, Value *CodeRegion)
727  PassName, RemarkName, DLoc, CodeRegion) {}
728 
729  static bool classof(const DiagnosticInfo *DI) {
731  }
732 };
733 
734 /// Diagnostic information for machine IR parser.
736  const SMDiagnostic &Diagnostic;
737 
738 public:
740  const SMDiagnostic &Diagnostic)
741  : DiagnosticInfo(DK_MIRParser, Severity), Diagnostic(Diagnostic) {}
742 
743  const SMDiagnostic &getDiagnostic() const { return Diagnostic; }
744 
745  void print(DiagnosticPrinter &DP) const override;
746 
747  static bool classof(const DiagnosticInfo *DI) {
748  return DI->getKind() == DK_MIRParser;
749  }
750 };
751 
752 /// Diagnostic information for ISel fallback path.
754  /// The function that is concerned by this diagnostic.
755  const Function &Fn;
756 
757 public:
759  DiagnosticSeverity Severity = DS_Warning)
760  : DiagnosticInfo(DK_ISelFallback, Severity), Fn(Fn) {}
761 
762  const Function &getFunction() const { return Fn; }
763 
764  void print(DiagnosticPrinter &DP) const override;
765 
766  static bool classof(const DiagnosticInfo *DI) {
767  return DI->getKind() == DK_ISelFallback;
768  }
769 };
770 
771 // Create wrappers for C Binding types (see CBindingWrapping.h).
773 
774 /// Emit an optimization-applied message. \p PassName is the name of the pass
775 /// emitting the message. If -Rpass= is given and \p PassName matches the
776 /// regular expression in -Rpass, then the remark will be emitted. \p Fn is
777 /// the function triggering the remark, \p DLoc is the debug location where
778 /// the diagnostic is generated. \p Msg is the message string to use.
779 void emitOptimizationRemark(LLVMContext &Ctx, const char *PassName,
780  const Function &Fn, const DebugLoc &DLoc,
781  const Twine &Msg);
782 
783 /// Emit an optimization-missed message. \p PassName is the name of the
784 /// pass emitting the message. If -Rpass-missed= is given and \p PassName
785 /// matches the regular expression in -Rpass, then the remark will be
786 /// emitted. \p Fn is the function triggering the remark, \p DLoc is the
787 /// debug location where the diagnostic is generated. \p Msg is the
788 /// message string to use.
789 void emitOptimizationRemarkMissed(LLVMContext &Ctx, const char *PassName,
790  const Function &Fn, const DebugLoc &DLoc,
791  const Twine &Msg);
792 
793 /// Emit an optimization analysis remark message. \p PassName is the name of
794 /// the pass emitting the message. If -Rpass-analysis= is given and \p
795 /// PassName matches the regular expression in -Rpass, then the remark will be
796 /// emitted. \p Fn is the function triggering the remark, \p DLoc is the debug
797 /// location where the diagnostic is generated. \p Msg is the message string
798 /// to use.
799 void emitOptimizationRemarkAnalysis(LLVMContext &Ctx, const char *PassName,
800  const Function &Fn, const DebugLoc &DLoc,
801  const Twine &Msg);
802 
803 /// Emit an optimization analysis remark related to messages about
804 /// floating-point non-commutativity. \p PassName is the name of the pass
805 /// emitting the message. If -Rpass-analysis= is given and \p PassName matches
806 /// the regular expression in -Rpass, then the remark will be emitted. \p Fn is
807 /// the function triggering the remark, \p DLoc is the debug location where the
808 /// diagnostic is generated. \p Msg is the message string to use.
809 void emitOptimizationRemarkAnalysisFPCommute(LLVMContext &Ctx,
810  const char *PassName,
811  const Function &Fn,
812  const DebugLoc &DLoc,
813  const Twine &Msg);
814 
815 /// Emit an optimization analysis remark related to messages about
816 /// pointer aliasing. \p PassName is the name of the pass emitting the message.
817 /// If -Rpass-analysis= is given and \p PassName matches the regular expression
818 /// in -Rpass, then the remark will be emitted. \p Fn is the function triggering
819 /// the remark, \p DLoc is the debug location where the diagnostic is generated.
820 /// \p Msg is the message string to use.
821 void emitOptimizationRemarkAnalysisAliasing(LLVMContext &Ctx,
822  const char *PassName,
823  const Function &Fn,
824  const DebugLoc &DLoc,
825  const Twine &Msg);
826 
827 /// Diagnostic information for optimization failures.
830 public:
831  /// \p Fn is the function where the diagnostic is being emitted. \p DLoc is
832  /// the location information to use in the diagnostic. If line table
833  /// information is available, the diagnostic will include the source code
834  /// location. \p Msg is the message to show. Note that this class does not
835  /// copy this message, so this reference must be valid for the whole life time
836  /// of the diagnostic.
838  const Twine &Msg)
839  : DiagnosticInfoOptimizationBase(DK_OptimizationFailure, DS_Warning,
840  nullptr, Fn, DLoc, Msg) {}
841 
842  static bool classof(const DiagnosticInfo *DI) {
843  return DI->getKind() == DK_OptimizationFailure;
844  }
845 
846  /// \see DiagnosticInfoOptimizationBase::isEnabled.
847  bool isEnabled() const override;
848 };
849 
850 /// Diagnostic information for unsupported feature in backend.
853 private:
854  Twine Msg;
855 
856 public:
857  /// \p Fn is the function where the diagnostic is being emitted. \p DLoc is
858  /// the location information to use in the diagnostic. If line table
859  /// information is available, the diagnostic will include the source code
860  /// location. \p Msg is the message to show. Note that this class does not
861  /// copy this message, so this reference must be valid for the whole life time
862  /// of the diagnostic.
863  DiagnosticInfoUnsupported(const Function &Fn, const Twine &Msg,
864  DebugLoc DLoc = DebugLoc(),
865  DiagnosticSeverity Severity = DS_Error)
866  : DiagnosticInfoWithDebugLocBase(DK_Unsupported, Severity, Fn, DLoc),
867  Msg(Msg) {}
868 
869  static bool classof(const DiagnosticInfo *DI) {
870  return DI->getKind() == DK_Unsupported;
871  }
872 
873  const Twine &getMessage() const { return Msg; }
874 
875  void print(DiagnosticPrinter &DP) const override;
876 };
877 
878 /// Emit a warning when loop vectorization is specified but fails. \p Fn is the
879 /// function triggering the warning, \p DLoc is the debug location where the
880 /// diagnostic is generated. \p Msg is the message string to use.
881 void emitLoopVectorizeWarning(LLVMContext &Ctx, const Function &Fn,
882  const DebugLoc &DLoc, const Twine &Msg);
883 
884 /// Emit a warning when loop interleaving is specified but fails. \p Fn is the
885 /// function triggering the warning, \p DLoc is the debug location where the
886 /// diagnostic is generated. \p Msg is the message string to use.
887 void emitLoopInterleaveWarning(LLVMContext &Ctx, const Function &Fn,
888  const DebugLoc &DLoc, const Twine &Msg);
889 
890 } // end namespace llvm
891 
892 #endif // LLVM_IR_DIAGNOSTICINFO_H
DiagnosticInfoSampleProfile(StringRef FileName, const Twine &Msg, DiagnosticSeverity Severity=DS_Error)
DiagnosticInfoISelFallback(const Function &Fn, DiagnosticSeverity Severity=DS_Warning)
Diagnostic information for ISel fallback path.
DiagnosticInfoSampleProfile(StringRef FileName, unsigned LineNum, const Twine &Msg, DiagnosticSeverity Severity=DS_Error)
DiagnosticKind
Defines the different supported kind of a diagnostic.
Diagnostic information for missed-optimization remarks.
LLVM Argument representation.
Definition: Argument.h:34
Diagnostic information for unsupported feature in backend.
DiagnosticInfoResourceLimit(const Function &Fn, const char *ResourceName, uint64_t ResourceSize, DiagnosticSeverity Severity=DS_Warning, DiagnosticKind Kind=DK_ResourceLimit, uint64_t ResourceLimit=0)
The function that is concerned by this stack size diagnostic.
DiagnosticInfoOptimizationBase(enum DiagnosticKind Kind, enum DiagnosticSeverity Severity, const char *PassName, StringRef RemarkName, const Function &Fn, const DebugLoc &DLoc, Value *CodeRegion=nullptr)
PassName is the name of the pass emitting this diagnostic.
const Function & getFunction() const
bool isLocationAvailable() const
Return true if location information is available for this diagnostic.
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:52
OptimizationRemarkMissed(const char *PassName, const Function &Fn, const DebugLoc &DLoc, const Twine &Msg, Optional< uint64_t > Hotness=None)
PassName is the name of the pass emitting this diagnostic.
DiagnosticInfoInlineAsm(const Twine &MsgStr, DiagnosticSeverity Severity=DS_Error)
MsgStr is the message to be reported to the frontend.
Diagnostic information for the PGO profiler.
static bool classof(const DiagnosticInfo *DI)
DiagnosticInfoOptimizationBase & operator<<(StringRef S)
void print(DiagnosticPrinter &DP) const override
DiagnosticInfoMIRParser(DiagnosticSeverity Severity, const SMDiagnostic &Diagnostic)
Used to set IsVerbose via the stream interface.
Diagnostic information for machine IR parser.
DiagnosticInfoInlineAsm(unsigned LocCookie, const Twine &MsgStr, DiagnosticSeverity Severity=DS_Error)
LocCookie if non-zero gives the line number for this report.
A debug info location.
Definition: DebugLoc.h:34
static bool classof(const DiagnosticInfo *DI)
const DebugLoc & getDebugLoc() const
void emitOptimizationRemark(LLVMContext &Ctx, const char *PassName, const Function &Fn, const DebugLoc &DLoc, const Twine &Msg)
Emit an optimization-applied message.
When an instance of this is inserted into the stream, the arguments following will not appear in the ...
Diagnostic information for stripping invalid debug metadata.
OptimizationRemarkAnalysisFPCommute(const char *PassName, const Function &Fn, const DebugLoc &DLoc, const Twine &Msg, Optional< uint64_t > Hotness=None)
PassName is the name of the pass emitting this diagnostic.
virtual ~DiagnosticInfo()=default
const Function & getFunction() const
OptimizationRemarkAnalysisAliasing(const char *PassName, StringRef RemarkName, const DebugLoc &DLoc, Value *CodeRegion)
PassName is the name of the pass emitting this diagnostic.
DiagnosticInfoOptimizationFailure(const Function &Fn, const DebugLoc &DLoc, const Twine &Msg)
Fn is the function where the diagnostic is being emitted.
static bool classof(const DiagnosticInfo *DI)
DiagnosticInfoIgnoringInvalidDebugMetadata(const Module &M, DiagnosticSeverity Severity=DS_Warning)
The module that is concerned by this debug metadata version diagnostic.
std::string str() const
Return the twine contents as a std::string.
Definition: Twine.cpp:17
DiagnosticSeverity
Defines the different supported severity of a diagnostic.
#define DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref)
DiagnosticInfoStackSize(const Function &Fn, uint64_t StackSize, DiagnosticSeverity Severity=DS_Warning, uint64_t StackLimit=0)
void emitOptimizationRemarkAnalysis(LLVMContext &Ctx, const char *PassName, const Function &Fn, const DebugLoc &DLoc, const Twine &Msg)
Emit an optimization analysis remark message.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
Diagnostic information for optimization failures.
Diagnostic information for optimization analysis remarks.
void getLocation(StringRef *Filename, unsigned *Line, unsigned *Column) const
Return location information for this diagnostic in three parts: the source file name, line number and column.
uint64_t getStackLimit() const
Interface for custom diagnostic printing.
DiagnosticInfo(int Kind, DiagnosticSeverity Severity)
Diagnostic information for stack size etc.
void emitOptimizationRemarkMissed(LLVMContext &Ctx, const char *PassName, const Function &Fn, const DebugLoc &DLoc, const Twine &Msg)
Emit an optimization-missed message.
This class should be specialized by any type that needs to be converted to/from a YAML mapping...
static bool classof(const DiagnosticInfo *DI)
void print(DiagnosticPrinter &DP) const override
DiagnosticInfoOptimizationBase::setExtraArgs setExtraArgs
static GCRegistry::Add< OcamlGC > B("ocaml","ocaml 3.10-compatible GC")
DiagnosticInfoOptimizationBase::setIsVerbose setIsVerbose
DiagnosticSeverity getSeverity() const
Diagnostic information for optimization analysis remarks related to pointer aliasing.
This is the base abstract class for diagnostic reporting in the backend.
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
const Twine & getMsg() const
#define H(x, y, z)
Definition: MD5.cpp:53
DiagnosticInfoWithDebugLocBase(enum DiagnosticKind Kind, enum DiagnosticSeverity Severity, const Function &Fn, const DebugLoc &DLoc)
Fn is the function where the diagnostic is being emitted.
Diagnostic information for applied optimization remarks.
static bool classof(const DiagnosticInfo *DI)
DiagnosticInfoPGOProfile(const char *FileName, const Twine &Msg, DiagnosticSeverity Severity=DS_Error)
const Twine & getMsg() const
const char * getFileName() const
DiagnosticInfoUnsupported(const Function &Fn, const Twine &Msg, DebugLoc DLoc=DebugLoc(), DiagnosticSeverity Severity=DS_Error)
Fn is the function where the diagnostic is being emitted.
static bool classof(const DiagnosticInfo *DI)
DiagnosticInfoOptimizationBase(const char *PassName, StringRef Prepend, const DiagnosticInfoOptimizationBase &Orig)
This is ctor variant allows a pass to build an optimization remark from an existing remark...
static bool classof(const DiagnosticInfo *DI)
const Instruction * getInstruction() const
Used in the streaming interface as the general argument type.
static bool classof(const DiagnosticInfo *DI)
struct LLVMOpaqueDiagnosticInfo * LLVMDiagnosticInfoRef
Definition: c/Types.h:121
Diagnostic information for inline asm reporting.
virtual void print(DiagnosticPrinter &DP) const =0
Print using the given DP a user-friendly message.
bool isEnabled() const override
void emitLoopVectorizeWarning(LLVMContext &Ctx, const Function &Fn, const DebugLoc &DLoc, const Twine &Msg)
Emit a warning when loop vectorization is specified but fails.
void print(DiagnosticPrinter &DP) const override
Print using the given DP a user-friendly message.
OptimizationRemarkAnalysisAliasing(const char *PassName, const Function &Fn, const DebugLoc &DLoc, const Twine &Msg, Optional< uint64_t > Hotness=None)
PassName is the name of the pass emitting this diagnostic.
void emitLoopInterleaveWarning(LLVMContext &Ctx, const Function &Fn, const DebugLoc &DLoc, const Twine &Msg)
Emit a warning when loop interleaving is specified but fails.
bool isEnabled() const override
unsigned getLocCookie() const
Diagnostic information for optimization analysis remarks related to floating-point non-commutativity...
static bool classof(const DiagnosticInfo *DI)
static bool classof(const DiagnosticInfo *DI)
Common features for diagnostics dealing with optimization remarks.
static bool classof(const DiagnosticInfo *DI)
static bool classof(const DiagnosticInfo *DI)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:843
std::function< void(const DiagnosticInfo &)> DiagnosticHandlerFunction
static bool classof(const DiagnosticInfo *DI)
static bool classof(const DiagnosticInfo *DI)
DiagnosticInfoOptimizationBase(enum DiagnosticKind Kind, enum DiagnosticSeverity Severity, const char *PassName, const Function &Fn, const DebugLoc &DLoc, const Twine &Msg, Optional< uint64_t > Hotness=None)
Legacy interface.
DiagnosticInfoDebugMetadataVersion(const Module &M, unsigned MetadataVersion, DiagnosticSeverity Severity=DS_Warning)
The module that is concerned by this debug metadata version diagnostic.
Optional< uint64_t > getHotness() const
int getNextAvailablePluginDiagnosticKind()
Get the next available kind ID for a plugin diagnostic.
void print(DiagnosticPrinter &DP) const override
OptimizationRemarkAnalysis(enum DiagnosticKind Kind, const char *PassName, const Function &Fn, const DebugLoc &DLoc, const Twine &Msg, Optional< uint64_t > Hotness)
void print(DiagnosticPrinter &DP) const override
Print using the given DP a user-friendly message.
Common features for diagnostics with an associated DebugLoc.
const char * getResourceName() const
void emitOptimizationRemarkAnalysisFPCommute(LLVMContext &Ctx, const char *PassName, const Function &Fn, const DebugLoc &DLoc, const Twine &Msg)
Emit an optimization analysis remark related to messages about floating-point non-commutativity.
void print(DiagnosticPrinter &DP) const override
#define I(x, y, z)
Definition: MD5.cpp:54
#define N
Diagnostic information for debug metadata version reporting.
const std::string getLocationStr() const
Return a string with the location information for this diagnostic in the format "file:line:col".
const Twine & getMessage() const
DiagnosticInfoSampleProfile(const Twine &Msg, DiagnosticSeverity Severity=DS_Error)
static bool classof(const DiagnosticInfo *DI)
void print(DiagnosticPrinter &DP) const override
static bool classof(const DiagnosticInfo *DI)
static bool isEnabled(StringRef Feature)
isEnabled - Return true if enable flag; '+'.
OptimizationRemarkAnalysis(const char *PassName, StringRef Prepend, const OptimizationRemarkAnalysis &Orig)
This is ctor variant allows a pass to build an optimization remark from an existing remark...
const Twine & getMsgStr() const
aarch64 promote const
LLVM Value Representation.
Definition: Value.h:71
const Function & getFunction() const
OptimizationRemarkAnalysis(const char *PassName, const Function &Fn, const DebugLoc &DLoc, const Twine &Msg, Optional< uint64_t > Hotness=None)
PassName is the name of the pass emitting this diagnostic.
void emitOptimizationRemarkAnalysisAliasing(LLVMContext &Ctx, const char *PassName, const Function &Fn, const DebugLoc &DLoc, const Twine &Msg)
Emit an optimization analysis remark related to messages about pointer aliasing.
void print(DiagnosticPrinter &DP) const override
const SMDiagnostic & getDiagnostic() const
void setHotness(Optional< uint64_t > H)
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:47
OptimizationRemark(const char *PassName, const Function &Fn, const DebugLoc &DLoc, const Twine &Msg, Optional< uint64_t > Hotness=None)
PassName is the name of the pass emitting this diagnostic.
void print(DiagnosticPrinter &DP) const override
OptimizationRemarkAnalysisFPCommute(const char *PassName, StringRef RemarkName, const DebugLoc &DLoc, Value *CodeRegion)
PassName is the name of the pass emitting this diagnostic.
Diagnostic information for the sample profiler.
void print(DiagnosticPrinter &DP) const override
Print using the given DP a user-friendly message.
static GCRegistry::Add< ErlangGC > A("erlang","erlang-compatible garbage collector")
static bool classof(const DiagnosticInfo *DI)
virtual bool isEnabled() const =0
Return true if this optimization remark is enabled by one of of the LLVM command line flags (-pass-re...
uint64_t getStackSize() const
Instances of this class encapsulate one diagnostic report, allowing printing to a raw_ostream as a ca...
Definition: SourceMgr.h:228