13 #ifndef MLIR_IR_DIAGNOSTICS_H
14 #define MLIR_IR_DIAGNOSTICS_H
27 class DiagnosticEngine;
31 class OpPrintingFlags;
36 struct DiagnosticEngineImpl;
65 T val, std::enable_if_t<std::is_signed<T>::value &&
66 std::numeric_limits<T>::is_integer &&
67 sizeof(T) <=
sizeof(int64_t)> * =
nullptr)
72 T val, std::enable_if_t<std::is_unsigned<T>::value &&
73 std::numeric_limits<T>::is_integer &&
74 sizeof(T) <=
sizeof(uint64_t)> * =
nullptr)
94 void print(raw_ostream &os)
const;
156 using NoteVector = std::vector<std::unique_ptr<Diagnostic>>;
160 : loc(loc), severity(severity) {}
175 template <
typename Arg>
176 std::enable_if_t<!std::is_convertible<Arg, StringRef>::value &&
177 std::is_constructible<DiagnosticArgument, Arg>::value,
209 template <
typename T,
typename ValueT = llvm::detail::ValueOfRange<T>>
210 std::enable_if_t<!std::is_constructible<DiagnosticArgument, T>::value,
218 template <
typename T>
221 c, [
this](
const auto &a) { *
this << a; }, [&]() { *
this << delim; });
226 template <
typename Arg1,
typename Arg2,
typename... Args>
228 append(std::forward<Arg1>(arg1));
229 return append(std::forward<Arg2>(arg2), std::forward<Args>(args)...);
232 template <
typename Arg>
234 *this << std::forward<Arg>(arg);
239 void print(raw_ostream &os)
const;
242 std::string
str()
const;
251 llvm::pointee_iterator<NoteVector::const_iterator>;
255 return llvm::make_pointee_range(notes);
258 return llvm::make_pointee_range(notes);
262 operator LogicalResult()
const;
265 operator ParseResult()
const {
return ParseResult(LogicalResult(*
this)); }
269 template <
typename T>
270 operator FailureOr<T>()
const {
292 std::vector<std::unique_ptr<char[]>> strings;
317 : owner(rhs.owner),
impl(std::move(rhs.
impl)) {
328 template <
typename Arg>
330 return append(std::forward<Arg>(arg));
332 template <
typename Arg>
334 return std::move(
append(std::forward<Arg>(arg)));
338 template <
typename... Args>
340 assert(isActive() &&
"diagnostic not active");
342 impl->append(std::forward<Args>(args)...);
345 template <
typename... Args>
347 return std::move(
append(std::forward<Args>(args)...));
352 assert(isActive() &&
"diagnostic not active");
353 return impl->attachNote(noteLoc);
368 operator LogicalResult()
const;
372 operator ParseResult()
const {
return ParseResult(LogicalResult(*
this)); }
377 template <
typename T>
378 operator FailureOr<T>()
const {
386 : owner(owner),
impl(std::move(rhs)) {}
390 bool isActive()
const {
return impl.has_value(); }
393 bool isInFlight()
const {
return owner; }
396 friend DiagnosticEngine;
399 DiagnosticEngine *owner =
nullptr;
402 std::optional<Diagnostic>
impl;
445 template <typename FuncTy, typename RetT = decltype(std::declval<FuncTy>()(
446 std::declval<Diagnostic &>()))>
447 std::enable_if_t<std::is_same<RetT, void>::value,
HandlerID>
461 "notes should not be emitted directly");
475 std::unique_ptr<detail::DiagnosticEngineImpl>
impl;
495 template <
typename... Args>
501 template <
typename... Args>
507 template <
typename... Args>
524 template <
typename FuncTy>
526 : handlerID(0), ctx(ctx) {
533 template <
typename FuncTy>
538 handlerID = diagEngine.registerHandler(std::forward<FuncTy>(handler));
554 struct SourceMgrDiagnosticHandlerImpl;
578 bool displaySourceLine =
true);
600 SMLoc convertLocToSMLoc(FileLineColLoc loc);
604 std::optional<Location> findLocToShow(
Location loc);
608 unsigned callStackLimit = 10;
610 std::unique_ptr<detail::SourceMgrDiagnosticHandlerImpl>
impl;
618 struct SourceMgrDiagnosticVerifierHandlerImpl;
643 std::unique_ptr<detail::SourceMgrDiagnosticVerifierHandlerImpl>
impl;
651 struct ParallelDiagnosticHandlerImpl;
681 std::unique_ptr<detail::ParallelDiagnosticHandlerImpl>
impl;
static std::string diag(const llvm::Value &value)
Attributes are known-constant values of operations.
A variant type that holds a single argument for a diagnostic.
DiagnosticArgumentKind
Enum that represents the different kinds of diagnostic arguments supported.
StringRef getAsString() const
Returns this argument as a string.
double getAsDouble() const
Returns this argument as a double.
DiagnosticArgument(Attribute attr)
Note: The constructors below are only exposed due to problems accessing constructors from type traits...
Type getAsType() const
Returns this argument as a Type.
int64_t getAsInteger() const
Returns this argument as a signed integer.
DiagnosticArgument(double val)
DiagnosticArgumentKind getKind() const
Returns the kind of this argument.
Attribute getAsAttribute() const
Returns this argument as an Attribute.
DiagnosticArgument(T val, std::enable_if_t< std::is_unsigned< T >::value &&std::numeric_limits< T >::is_integer &&sizeof(T)<=sizeof(uint64_t)> *=nullptr)
void print(raw_ostream &os) const
Outputs this argument to a stream.
DiagnosticArgument(float val)
uint64_t getAsUnsigned() const
Returns this argument as an unsigned integer.
DiagnosticArgument(StringRef val)
DiagnosticArgument(T val, std::enable_if_t< std::is_signed< T >::value &&std::numeric_limits< T >::is_integer &&sizeof(T)<=sizeof(int64_t)> *=nullptr)
This class is the main interface for diagnostics.
uint64_t HandlerID
A handle to a specific registered handler object.
InFlightDiagnostic emit(Location loc, DiagnosticSeverity severity)
Create a new inflight diagnostic with the given location and severity.
std::enable_if_t< std::is_same< RetT, void >::value, HandlerID > registerHandler(FuncTy &&handler)
Set the diagnostic handler with a function that returns void.
void eraseHandler(HandlerID id)
Erase the registered diagnostic handler with the given identifier.
llvm::unique_function< LogicalResult(Diagnostic &)> HandlerTy
The handler type for MLIR diagnostics.
HandlerID registerHandler(HandlerTy handler)
Register a new handler for diagnostics to the engine.
This class contains all of the information necessary to report a diagnostic to the DiagnosticEngine.
DiagnosticSeverity getSeverity() const
Returns the severity of this diagnostic.
SmallVectorImpl< DiagnosticArgument > & getMetadata()
Returns the current list of diagnostic metadata.
std::string str() const
Converts the diagnostic to a string.
iterator_range< note_iterator > getNotes()
Returns the notes held by this diagnostic.
Diagnostic & operator<<(Operation *op)
Diagnostic & append(Arg1 &&arg1, Arg2 &&arg2, Args &&...args)
Append arguments to the diagnostic.
Location getLocation() const
Returns the source location for this diagnostic.
Diagnostic & attachNote(std::optional< Location > noteLoc=std::nullopt)
Attaches a note to this diagnostic.
Diagnostic & appendRange(const T &c, const char *delim=", ")
Append a range to the diagnostic.
Diagnostic & operator=(Diagnostic &&)=default
llvm::pointee_iterator< NoteVector::iterator > note_iterator
MutableArrayRef< DiagnosticArgument > getArguments()
Returns the current list of diagnostic arguments.
Diagnostic(Location loc, DiagnosticSeverity severity)
std::enable_if_t<!std::is_constructible< DiagnosticArgument, T >::value, Diagnostic & > operator<<(T &&range)
Stream in a range.
llvm::pointee_iterator< NoteVector::const_iterator > const_note_iterator
Diagnostic & append(Arg &&arg)
Append one argument to the diagnostic.
iterator_range< const_note_iterator > getNotes() const
std::enable_if_t<!std::is_convertible< Arg, StringRef >::value &&std::is_constructible< DiagnosticArgument, Arg >::value, Diagnostic & > operator<<(Arg &&val)
Stream operator for inserting new diagnostic arguments.
ArrayRef< DiagnosticArgument > getArguments() const
Diagnostic & operator<<(const char *val)
Stream in a string literal.
Diagnostic(Diagnostic &&)=default
void print(raw_ostream &os) const
Outputs this diagnostic to a stream.
Diagnostic & appendOp(Operation &op, const OpPrintingFlags &flags)
Append an operation with the given printing flags.
This class represents a diagnostic that is inflight and set to be reported.
InFlightDiagnostic && operator<<(Arg &&arg) &&
Diagnostic & attachNote(std::optional< Location > noteLoc=std::nullopt)
Attaches a note to this diagnostic.
InFlightDiagnostic & operator<<(Arg &&arg) &
Stream operator for new diagnostic arguments.
InFlightDiagnostic & append(Args &&...args) &
Append arguments to the diagnostic.
InFlightDiagnostic && append(Args &&...args) &&
InFlightDiagnostic()=default
void report()
Reports the diagnostic to the engine.
Diagnostic * getUnderlyingDiagnostic()
Returns the underlying diagnostic or nullptr if this diagnostic isn't active.
InFlightDiagnostic(InFlightDiagnostic &&rhs)
void abandon()
Abandons this diagnostic so that it will no longer be reported.
This class defines the main interface for locations in MLIR and acts as a non-nullable wrapper around...
This is the implementation of the MLIRContext class, using the pImpl idiom.
MLIRContext is the top-level object for a collection of MLIR operations.
DiagnosticEngine & getDiagEngine()
Returns the diagnostic engine for this context.
Set of flags used to control the behavior of the various IR print methods (e.g.
Operation is the basic unit of execution within MLIR.
This class is a utility diagnostic handler for use when multi-threading some part of the compiler whe...
void eraseOrderIDForThread()
Remove the order id for the current thread.
~ParallelDiagnosticHandler()
ParallelDiagnosticHandler(MLIRContext *ctx)
void setOrderIDForThread(size_t orderID)
Set the order id for the current thread.
This diagnostic handler is a simple RAII class that registers and erases a diagnostic handler on a gi...
~ScopedDiagnosticHandler()
ScopedDiagnosticHandler(MLIRContext *ctx)
ScopedDiagnosticHandler(MLIRContext *ctx, FuncTy &&handler)
void setHandler(FuncTy &&handler)
Set the handler to manage via RAII.
This class is a utility diagnostic handler for use with llvm::SourceMgr.
void emitDiagnostic(Location loc, Twine message, DiagnosticSeverity kind, bool displaySourceLine=true)
Emit the given diagnostic information with the held source manager.
raw_ostream & os
The output stream to use when printing diagnostics.
SourceMgrDiagnosticHandler(llvm::SourceMgr &mgr, MLIRContext *ctx, raw_ostream &os, ShouldShowLocFn &&shouldShowLocFn={})
~SourceMgrDiagnosticHandler()
ShouldShowLocFn shouldShowLocFn
A functor used when determining if a location for a diagnostic should be shown.
const llvm::MemoryBuffer * getBufferForFile(StringRef filename)
Get a memory buffer for the given file, or nullptr if no file is available.
llvm::SourceMgr & mgr
The source manager that we are wrapping.
llvm::unique_function< bool(Location)> ShouldShowLocFn
This type represents a functor used to filter out locations when printing a diagnostic.
This class is a utility diagnostic handler for use with llvm::SourceMgr that verifies that emitted di...
~SourceMgrDiagnosticVerifierHandler()
LogicalResult verify()
Returns the status of the handler and verifies that all expected diagnostics were emitted.
SourceMgrDiagnosticVerifierHandler(llvm::SourceMgr &srcMgr, MLIRContext *ctx, raw_ostream &out)
Instances of the Type class are uniqued, have an immutable identifier and an optional mutable compone...
This class represents an instance of an SSA value in the MLIR system, representing a computable value...
The OpAsmOpInterface, see OpAsmInterface.td for more details.
@ Type
An inlay hint that for a type annotation.
Include the generated interface declarations.
InFlightDiagnostic emitWarning(Location loc)
Utility method to emit a warning message using this location.
DiagnosticSeverity
Defines the different supported severity of a diagnostic.
LogicalResult emitOptionalRemark(std::optional< Location > loc, Args &&...args)
LogicalResult emitOptionalError(std::optional< Location > loc, Args &&...args)
Overloads of the above emission functions that take an optionally null location.
InFlightDiagnostic emitError(Location loc)
Utility method to emit an error message using this location.
InFlightDiagnostic emitRemark(Location loc)
Utility method to emit a remark message using this location.
LogicalResult emitOptionalWarning(std::optional< Location > loc, Args &&...args)
raw_ostream & operator<<(raw_ostream &os, const AliasResult &result)