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,
210 template <
typename T,
typename ValueT = llvm::detail::ValueOfRange<T>>
211 std::enable_if_t<!std::is_constructible<DiagnosticArgument, T>::value,
219 template <
typename T>
222 c, [
this](
const auto &a) { *
this << a; }, [&]() { *
this << delim; });
227 template <
typename Arg1,
typename Arg2,
typename... Args>
229 append(std::forward<Arg1>(arg1));
230 return append(std::forward<Arg2>(arg2), std::forward<Args>(args)...);
233 template <
typename Arg>
235 *this << std::forward<Arg>(arg);
240 void print(raw_ostream &os)
const;
243 std::string
str()
const;
252 llvm::pointee_iterator<NoteVector::const_iterator>;
256 return llvm::make_pointee_range(notes);
259 return llvm::make_pointee_range(notes);
263 operator LogicalResult()
const;
266 operator ParseResult()
const {
return ParseResult(LogicalResult(*
this)); }
270 template <
typename T>
271 operator FailureOr<T>()
const {
293 std::vector<std::unique_ptr<char[]>> strings;
318 : owner(rhs.owner),
impl(std::move(rhs.
impl)) {
329 template <
typename Arg>
331 return append(std::forward<Arg>(arg));
333 template <
typename Arg>
335 return std::move(
append(std::forward<Arg>(arg)));
339 template <
typename... Args>
341 assert(isActive() &&
"diagnostic not active");
343 impl->append(std::forward<Args>(args)...);
346 template <
typename... Args>
348 return std::move(
append(std::forward<Args>(args)...));
353 assert(isActive() &&
"diagnostic not active");
354 return impl->attachNote(noteLoc);
369 operator LogicalResult()
const;
373 operator ParseResult()
const {
return ParseResult(LogicalResult(*
this)); }
378 template <
typename T>
379 operator FailureOr<T>()
const {
387 : owner(owner),
impl(std::move(rhs)) {}
391 bool isActive()
const {
return impl.has_value(); }
394 bool isInFlight()
const {
return owner; }
397 friend DiagnosticEngine;
400 DiagnosticEngine *owner =
nullptr;
403 std::optional<Diagnostic>
impl;
446 template <typename FuncTy, typename RetT = decltype(std::declval<FuncTy>()(
447 std::declval<Diagnostic &>()))>
448 std::enable_if_t<std::is_same<RetT, void>::value,
HandlerID>
462 "notes should not be emitted directly");
476 std::unique_ptr<detail::DiagnosticEngineImpl>
impl;
496 template <
typename... Args>
502 template <
typename... Args>
508 template <
typename... Args>
525 template <
typename FuncTy>
527 : handlerID(0), ctx(ctx) {
534 template <
typename FuncTy>
539 handlerID = diagEngine.registerHandler(std::forward<FuncTy>(handler));
555 struct SourceMgrDiagnosticHandlerImpl;
579 bool displaySourceLine =
true);
605 std::optional<Location> findLocToShow(
Location loc);
609 unsigned callStackLimit = 10;
611 std::unique_ptr<detail::SourceMgrDiagnosticHandlerImpl>
impl;
619 struct SourceMgrDiagnosticVerifierHandlerImpl;
644 std::unique_ptr<detail::SourceMgrDiagnosticVerifierHandlerImpl>
impl;
652 struct ParallelDiagnosticHandlerImpl;
682 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.
Diagnostic & operator<<(const char(&val)[n])
Stream in a string literal.
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(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.
An instance of this location represents a tuple of file, line number, and column number.
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)