MLIR  19.0.0git
OpImplementation.h
Go to the documentation of this file.
1 //===- OpImplementation.h - Classes for implementing Op types ---*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This classes used by the implementation details of Op types.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef MLIR_IR_OPIMPLEMENTATION_H
14 #define MLIR_IR_OPIMPLEMENTATION_H
15 
16 #include "mlir/IR/BuiltinTypes.h"
18 #include "mlir/IR/OpDefinition.h"
19 #include "llvm/ADT/Twine.h"
20 #include "llvm/Support/SMLoc.h"
21 #include <optional>
22 
23 namespace mlir {
24 class AsmParsedResourceEntry;
25 class AsmResourceBuilder;
26 class Builder;
27 
28 //===----------------------------------------------------------------------===//
29 // AsmDialectResourceHandle
30 //===----------------------------------------------------------------------===//
31 
32 /// This class represents an opaque handle to a dialect resource entry.
34 public:
36  AsmDialectResourceHandle(void *resource, TypeID resourceID, Dialect *dialect)
37  : resource(resource), opaqueID(resourceID), dialect(dialect) {}
38  bool operator==(const AsmDialectResourceHandle &other) const {
39  return resource == other.resource;
40  }
41 
42  /// Return an opaque pointer to the referenced resource.
43  void *getResource() const { return resource; }
44 
45  /// Return the type ID of the resource.
46  TypeID getTypeID() const { return opaqueID; }
47 
48  /// Return the dialect that owns the resource.
49  Dialect *getDialect() const { return dialect; }
50 
51 private:
52  /// The opaque handle to the dialect resource.
53  void *resource = nullptr;
54  /// The type of the resource referenced.
55  TypeID opaqueID;
56  /// The dialect owning the given resource.
57  Dialect *dialect;
58 };
59 
60 /// This class represents a CRTP base class for dialect resource handles. It
61 /// abstracts away various utilities necessary for defined derived resource
62 /// handles.
63 template <typename DerivedT, typename ResourceT, typename DialectT>
65 public:
66  using Dialect = DialectT;
67 
68  /// Construct a handle from a pointer to the resource. The given pointer
69  /// should be guaranteed to live beyond the life of this handle.
70  AsmDialectResourceHandleBase(ResourceT *resource, DialectT *dialect)
71  : AsmDialectResourceHandle(resource, TypeID::get<DerivedT>(), dialect) {}
73  : AsmDialectResourceHandle(handle) {
74  assert(handle.getTypeID() == TypeID::get<DerivedT>());
75  }
76 
77  /// Return the resource referenced by this handle.
78  ResourceT *getResource() {
79  return static_cast<ResourceT *>(AsmDialectResourceHandle::getResource());
80  }
81  const ResourceT *getResource() const {
82  return const_cast<AsmDialectResourceHandleBase *>(this)->getResource();
83  }
84 
85  /// Return the dialect that owns the resource.
86  DialectT *getDialect() const {
87  return static_cast<DialectT *>(AsmDialectResourceHandle::getDialect());
88  }
89 
90  /// Support llvm style casting.
91  static bool classof(const AsmDialectResourceHandle *handle) {
92  return handle->getTypeID() == TypeID::get<DerivedT>();
93  }
94 };
95 
96 inline llvm::hash_code hash_value(const AsmDialectResourceHandle &param) {
97  return llvm::hash_value(param.getResource());
98 }
99 
100 //===----------------------------------------------------------------------===//
101 // AsmPrinter
102 //===----------------------------------------------------------------------===//
103 
104 /// This base class exposes generic asm printer hooks, usable across the various
105 /// derived printers.
106 class AsmPrinter {
107 public:
108  /// This class contains the internal default implementation of the base
109  /// printer methods.
110  class Impl;
111 
112  /// Initialize the printer with the given internal implementation.
114  virtual ~AsmPrinter();
115 
116  /// Return the raw output stream used by this printer.
117  virtual raw_ostream &getStream() const;
118 
119  /// Print the given floating point value in a stabilized form that can be
120  /// roundtripped through the IR. This is the companion to the 'parseFloat'
121  /// hook on the AsmParser.
122  virtual void printFloat(const APFloat &value);
123 
124  virtual void printType(Type type);
125  virtual void printAttribute(Attribute attr);
126 
127  /// Trait to check if `AttrType` provides a `print` method.
128  template <typename AttrOrType>
130  decltype(std::declval<AttrOrType>().print(std::declval<AsmPrinter &>()));
131  template <typename AttrOrType>
133  llvm::is_detected<has_print_method, AttrOrType>;
134 
135  /// Print the provided attribute in the context of an operation custom
136  /// printer/parser: this will invoke directly the print method on the
137  /// attribute class and skip the `#dialect.mnemonic` prefix in most cases.
138  template <typename AttrOrType,
139  std::enable_if_t<detect_has_print_method<AttrOrType>::value>
140  *sfinae = nullptr>
141  void printStrippedAttrOrType(AttrOrType attrOrType) {
142  if (succeeded(printAlias(attrOrType)))
143  return;
144 
145  raw_ostream &os = getStream();
146  uint64_t posPrior = os.tell();
147  attrOrType.print(*this);
148  if (posPrior != os.tell())
149  return;
150 
151  // Fallback to printing with prefix if the above failed to write anything
152  // to the output stream.
153  *this << attrOrType;
154  }
155 
156  /// Print the provided array of attributes or types in the context of an
157  /// operation custom printer/parser: this will invoke directly the print
158  /// method on the attribute class and skip the `#dialect.mnemonic` prefix in
159  /// most cases.
160  template <typename AttrOrType,
161  std::enable_if_t<detect_has_print_method<AttrOrType>::value>
162  *sfinae = nullptr>
164  llvm::interleaveComma(
165  attrOrTypes, getStream(),
166  [this](AttrOrType attrOrType) { printStrippedAttrOrType(attrOrType); });
167  }
168 
169  /// SFINAE for printing the provided attribute in the context of an operation
170  /// custom printer in the case where the attribute does not define a print
171  /// method.
172  template <typename AttrOrType,
173  std::enable_if_t<!detect_has_print_method<AttrOrType>::value>
174  *sfinae = nullptr>
175  void printStrippedAttrOrType(AttrOrType attrOrType) {
176  *this << attrOrType;
177  }
178 
179  /// Print the given attribute without its type. The corresponding parser must
180  /// provide a valid type for the attribute.
181  virtual void printAttributeWithoutType(Attribute attr);
182 
183  /// Print the alias for the given attribute, return failure if no alias could
184  /// be printed.
185  virtual LogicalResult printAlias(Attribute attr);
186 
187  /// Print the alias for the given type, return failure if no alias could
188  /// be printed.
189  virtual LogicalResult printAlias(Type type);
190 
191  /// Print the given string as a keyword, or a quoted and escaped string if it
192  /// has any special or non-printable characters in it.
193  virtual void printKeywordOrString(StringRef keyword);
194 
195  /// Print the given string as a quoted string, escaping any special or
196  /// non-printable characters in it.
197  virtual void printString(StringRef string);
198 
199  /// Print the given string as a symbol reference, i.e. a form representable by
200  /// a SymbolRefAttr. A symbol reference is represented as a string prefixed
201  /// with '@'. The reference is surrounded with ""'s and escaped if it has any
202  /// special or non-printable characters in it.
203  virtual void printSymbolName(StringRef symbolRef);
204 
205  /// Print a handle to the given dialect resource.
206  virtual void printResourceHandle(const AsmDialectResourceHandle &resource);
207 
208  /// Print an optional arrow followed by a type list.
209  template <typename TypeRange>
211  if (types.begin() != types.end())
212  printArrowTypeList(types);
213  }
214  template <typename TypeRange>
216  auto &os = getStream() << " -> ";
217 
218  bool wrapped = !llvm::hasSingleElement(types) ||
219  llvm::isa<FunctionType>((*types.begin()));
220  if (wrapped)
221  os << '(';
222  llvm::interleaveComma(types, *this);
223  if (wrapped)
224  os << ')';
225  }
226 
227  /// Print the two given type ranges in a functional form.
228  template <typename InputRangeT, typename ResultRangeT>
229  void printFunctionalType(InputRangeT &&inputs, ResultRangeT &&results) {
230  auto &os = getStream();
231  os << '(';
232  llvm::interleaveComma(inputs, *this);
233  os << ')';
234  printArrowTypeList(results);
235  }
236 
238 
239  /// Class used to automatically end a cyclic region on destruction.
241  public:
242  explicit CyclicPrintReset(AsmPrinter *printer) : printer(printer) {}
243 
245  if (printer)
246  printer->popCyclicPrinting();
247  }
248 
250 
252 
254  : printer(std::exchange(rhs.printer, nullptr)) {}
255 
257  printer = std::exchange(rhs.printer, nullptr);
258  return *this;
259  }
260 
261  private:
262  AsmPrinter *printer;
263  };
264 
265  /// Attempts to start a cyclic printing region for `attrOrType`.
266  /// A cyclic printing region starts with this call and ends with the
267  /// destruction of the returned `CyclicPrintReset`. During this time,
268  /// calling `tryStartCyclicPrint` with the same attribute in any printer
269  /// will lead to returning failure.
270  ///
271  /// This makes it possible to break infinite recursions when trying to print
272  /// cyclic attributes or types by printing only immutable parameters if nested
273  /// within itself.
274  template <class AttrOrTypeT>
275  FailureOr<CyclicPrintReset> tryStartCyclicPrint(AttrOrTypeT attrOrType) {
276  static_assert(
277  std::is_base_of_v<AttributeTrait::IsMutable<AttrOrTypeT>,
278  AttrOrTypeT> ||
279  std::is_base_of_v<TypeTrait::IsMutable<AttrOrTypeT>, AttrOrTypeT>,
280  "Only mutable attributes or types can be cyclic");
281  if (failed(pushCyclicPrinting(attrOrType.getAsOpaquePointer())))
282  return failure();
283  return CyclicPrintReset(this);
284  }
285 
286 protected:
287  /// Initialize the printer with no internal implementation. In this case, all
288  /// virtual methods of this class must be overriden.
289  AsmPrinter() = default;
290 
291  /// Pushes a new attribute or type in the form of a type erased pointer
292  /// into an internal set.
293  /// Returns success if the type or attribute was inserted in the set or
294  /// failure if it was already contained.
295  virtual LogicalResult pushCyclicPrinting(const void *opaquePointer);
296 
297  /// Removes the element that was last inserted with a successful call to
298  /// `pushCyclicPrinting`. There must be exactly one `popCyclicPrinting` call
299  /// in reverse order of all successful `pushCyclicPrinting`.
300  virtual void popCyclicPrinting();
301 
302 private:
303  AsmPrinter(const AsmPrinter &) = delete;
304  void operator=(const AsmPrinter &) = delete;
305 
306  /// The internal implementation of the printer.
307  Impl *impl{nullptr};
308 };
309 
310 template <typename AsmPrinterT>
311 inline std::enable_if_t<std::is_base_of<AsmPrinter, AsmPrinterT>::value,
312  AsmPrinterT &>
313 operator<<(AsmPrinterT &p, Type type) {
314  p.printType(type);
315  return p;
316 }
317 
318 template <typename AsmPrinterT>
319 inline std::enable_if_t<std::is_base_of<AsmPrinter, AsmPrinterT>::value,
320  AsmPrinterT &>
321 operator<<(AsmPrinterT &p, Attribute attr) {
322  p.printAttribute(attr);
323  return p;
324 }
325 
326 template <typename AsmPrinterT>
327 inline std::enable_if_t<std::is_base_of<AsmPrinter, AsmPrinterT>::value,
328  AsmPrinterT &>
329 operator<<(AsmPrinterT &p, const APFloat &value) {
330  p.printFloat(value);
331  return p;
332 }
333 template <typename AsmPrinterT>
334 inline std::enable_if_t<std::is_base_of<AsmPrinter, AsmPrinterT>::value,
335  AsmPrinterT &>
336 operator<<(AsmPrinterT &p, float value) {
337  return p << APFloat(value);
338 }
339 template <typename AsmPrinterT>
340 inline std::enable_if_t<std::is_base_of<AsmPrinter, AsmPrinterT>::value,
341  AsmPrinterT &>
342 operator<<(AsmPrinterT &p, double value) {
343  return p << APFloat(value);
344 }
345 
346 // Support printing anything that isn't convertible to one of the other
347 // streamable types, even if it isn't exactly one of them. For example, we want
348 // to print FunctionType with the Type version above, not have it match this.
349 template <typename AsmPrinterT, typename T,
350  std::enable_if_t<!std::is_convertible<T &, Value &>::value &&
351  !std::is_convertible<T &, Type &>::value &&
352  !std::is_convertible<T &, Attribute &>::value &&
353  !std::is_convertible<T &, ValueRange>::value &&
354  !std::is_convertible<T &, APFloat &>::value &&
355  !llvm::is_one_of<T, bool, float, double>::value,
356  T> * = nullptr>
357 inline std::enable_if_t<std::is_base_of<AsmPrinter, AsmPrinterT>::value,
358  AsmPrinterT &>
359 operator<<(AsmPrinterT &p, const T &other) {
360  p.getStream() << other;
361  return p;
362 }
363 
364 template <typename AsmPrinterT>
365 inline std::enable_if_t<std::is_base_of<AsmPrinter, AsmPrinterT>::value,
366  AsmPrinterT &>
367 operator<<(AsmPrinterT &p, bool value) {
368  return p << (value ? StringRef("true") : "false");
369 }
370 
371 template <typename AsmPrinterT, typename ValueRangeT>
372 inline std::enable_if_t<std::is_base_of<AsmPrinter, AsmPrinterT>::value,
373  AsmPrinterT &>
374 operator<<(AsmPrinterT &p, const ValueTypeRange<ValueRangeT> &types) {
375  llvm::interleaveComma(types, p);
376  return p;
377 }
378 
379 template <typename AsmPrinterT>
380 inline std::enable_if_t<std::is_base_of<AsmPrinter, AsmPrinterT>::value,
381  AsmPrinterT &>
382 operator<<(AsmPrinterT &p, const TypeRange &types) {
383  llvm::interleaveComma(types, p);
384  return p;
385 }
386 
387 // Prevent matching the TypeRange version above for ValueRange
388 // printing through base AsmPrinter. This is needed so that the
389 // ValueRange printing behaviour does not change from printing
390 // the SSA values to printing the types for the operands when
391 // using AsmPrinter instead of OpAsmPrinter.
392 template <typename AsmPrinterT, typename T>
393 inline std::enable_if_t<std::is_same<AsmPrinter, AsmPrinterT>::value &&
394  std::is_convertible<T &, ValueRange>::value,
395  AsmPrinterT &>
396 operator<<(AsmPrinterT &p, const T &other) = delete;
397 
398 template <typename AsmPrinterT, typename ElementT>
399 inline std::enable_if_t<std::is_base_of<AsmPrinter, AsmPrinterT>::value,
400  AsmPrinterT &>
401 operator<<(AsmPrinterT &p, ArrayRef<ElementT> types) {
402  llvm::interleaveComma(types, p);
403  return p;
404 }
405 
406 //===----------------------------------------------------------------------===//
407 // OpAsmPrinter
408 //===----------------------------------------------------------------------===//
409 
410 /// This is a pure-virtual base class that exposes the asmprinter hooks
411 /// necessary to implement a custom print() method.
412 class OpAsmPrinter : public AsmPrinter {
413 public:
415  ~OpAsmPrinter() override;
416 
417  /// Print a loc(...) specifier if printing debug info is enabled.
419 
420  /// Print a newline and indent the printer to the start of the current
421  /// operation.
422  virtual void printNewline() = 0;
423 
424  /// Increase indentation.
425  virtual void increaseIndent() = 0;
426 
427  /// Decrease indentation.
428  virtual void decreaseIndent() = 0;
429 
430  /// Print a block argument in the usual format of:
431  /// %ssaName : type {attr1=42} loc("here")
432  /// where location printing is controlled by the standard internal option.
433  /// You may pass omitType=true to not print a type, and pass an empty
434  /// attribute list if you don't care for attributes.
436  ArrayRef<NamedAttribute> argAttrs = {},
437  bool omitType = false) = 0;
438 
439  /// Print implementations for various things an operation contains.
440  virtual void printOperand(Value value) = 0;
441  virtual void printOperand(Value value, raw_ostream &os) = 0;
442 
443  /// Print a comma separated list of operands.
444  template <typename ContainerType>
445  void printOperands(const ContainerType &container) {
446  printOperands(container.begin(), container.end());
447  }
448 
449  /// Print a comma separated list of operands.
450  template <typename IteratorType>
451  void printOperands(IteratorType it, IteratorType end) {
452  llvm::interleaveComma(llvm::make_range(it, end), getStream(),
453  [this](Value value) { printOperand(value); });
454  }
455 
456  /// Print the given successor.
457  virtual void printSuccessor(Block *successor) = 0;
458 
459  /// Print the successor and its operands.
460  virtual void printSuccessorAndUseList(Block *successor,
461  ValueRange succOperands) = 0;
462 
463  /// If the specified operation has attributes, print out an attribute
464  /// dictionary with their values. elidedAttrs allows the client to ignore
465  /// specific well known attributes, commonly used if the attribute value is
466  /// printed some other way (like as a fixed operand).
468  ArrayRef<StringRef> elidedAttrs = {}) = 0;
469 
470  /// If the specified operation has attributes, print out an attribute
471  /// dictionary prefixed with 'attributes'.
472  virtual void
474  ArrayRef<StringRef> elidedAttrs = {}) = 0;
475 
476  /// Prints the entire operation with the custom assembly form, if available,
477  /// or the generic assembly form, otherwise.
478  virtual void printCustomOrGenericOp(Operation *op) = 0;
479 
480  /// Print the entire operation with the default generic assembly form.
481  /// If `printOpName` is true, then the operation name is printed (the default)
482  /// otherwise it is omitted and the print will start with the operand list.
483  virtual void printGenericOp(Operation *op, bool printOpName = true) = 0;
484 
485  /// Prints a region.
486  /// If 'printEntryBlockArgs' is false, the arguments of the
487  /// block are not printed. If 'printBlockTerminator' is false, the terminator
488  /// operation of the block is not printed. If printEmptyBlock is true, then
489  /// the block header is printed even if the block is empty.
490  virtual void printRegion(Region &blocks, bool printEntryBlockArgs = true,
491  bool printBlockTerminators = true,
492  bool printEmptyBlock = false) = 0;
493 
494  /// Renumber the arguments for the specified region to the same names as the
495  /// SSA values in namesToUse. This may only be used for IsolatedFromAbove
496  /// operations. If any entry in namesToUse is null, the corresponding
497  /// argument name is left alone.
498  virtual void shadowRegionArgs(Region &region, ValueRange namesToUse) = 0;
499 
500  /// Prints an affine map of SSA ids, where SSA id names are used in place
501  /// of dims/symbols.
502  /// Operand values must come from single-result sources, and be valid
503  /// dimensions/symbol identifiers according to mlir::isValidDim/Symbol.
504  virtual void printAffineMapOfSSAIds(AffineMapAttr mapAttr,
505  ValueRange operands) = 0;
506 
507  /// Prints an affine expression of SSA ids with SSA id names used instead of
508  /// dims and symbols.
509  /// Operand values must come from single-result sources, and be valid
510  /// dimensions/symbol identifiers according to mlir::isValidDim/Symbol.
511  virtual void printAffineExprOfSSAIds(AffineExpr expr, ValueRange dimOperands,
512  ValueRange symOperands) = 0;
513 
514  /// Print the complete type of an operation in functional form.
515  void printFunctionalType(Operation *op);
517 };
518 
519 // Make the implementations convenient to use.
521  p.printOperand(value);
522  return p;
523 }
524 
525 template <typename T,
526  std::enable_if_t<std::is_convertible<T &, ValueRange>::value &&
527  !std::is_convertible<T &, Value &>::value,
528  T> * = nullptr>
529 inline OpAsmPrinter &operator<<(OpAsmPrinter &p, const T &values) {
530  p.printOperands(values);
531  return p;
532 }
533 
535  p.printSuccessor(value);
536  return p;
537 }
538 
539 //===----------------------------------------------------------------------===//
540 // AsmParser
541 //===----------------------------------------------------------------------===//
542 
543 /// This base class exposes generic asm parser hooks, usable across the various
544 /// derived parsers.
545 class AsmParser {
546 public:
547  AsmParser() = default;
548  virtual ~AsmParser();
549 
550  MLIRContext *getContext() const;
551 
552  /// Return the location of the original name token.
553  virtual SMLoc getNameLoc() const = 0;
554 
555  //===--------------------------------------------------------------------===//
556  // Utilities
557  //===--------------------------------------------------------------------===//
558 
559  /// Emit a diagnostic at the specified location and return failure.
560  virtual InFlightDiagnostic emitError(SMLoc loc,
561  const Twine &message = {}) = 0;
562 
563  /// Return a builder which provides useful access to MLIRContext, global
564  /// objects like types and attributes.
565  virtual Builder &getBuilder() const = 0;
566 
567  /// Get the location of the next token and store it into the argument. This
568  /// always succeeds.
569  virtual SMLoc getCurrentLocation() = 0;
570  ParseResult getCurrentLocation(SMLoc *loc) {
571  *loc = getCurrentLocation();
572  return success();
573  }
574 
575  /// Re-encode the given source location as an MLIR location and return it.
576  /// Note: This method should only be used when a `Location` is necessary, as
577  /// the encoding process is not efficient.
578  virtual Location getEncodedSourceLoc(SMLoc loc) = 0;
579 
580  //===--------------------------------------------------------------------===//
581  // Token Parsing
582  //===--------------------------------------------------------------------===//
583 
584  /// Parse a '->' token.
585  virtual ParseResult parseArrow() = 0;
586 
587  /// Parse a '->' token if present
588  virtual ParseResult parseOptionalArrow() = 0;
589 
590  /// Parse a `{` token.
591  virtual ParseResult parseLBrace() = 0;
592 
593  /// Parse a `{` token if present.
594  virtual ParseResult parseOptionalLBrace() = 0;
595 
596  /// Parse a `}` token.
597  virtual ParseResult parseRBrace() = 0;
598 
599  /// Parse a `}` token if present.
600  virtual ParseResult parseOptionalRBrace() = 0;
601 
602  /// Parse a `:` token.
603  virtual ParseResult parseColon() = 0;
604 
605  /// Parse a `:` token if present.
606  virtual ParseResult parseOptionalColon() = 0;
607 
608  /// Parse a `,` token.
609  virtual ParseResult parseComma() = 0;
610 
611  /// Parse a `,` token if present.
612  virtual ParseResult parseOptionalComma() = 0;
613 
614  /// Parse a `=` token.
615  virtual ParseResult parseEqual() = 0;
616 
617  /// Parse a `=` token if present.
618  virtual ParseResult parseOptionalEqual() = 0;
619 
620  /// Parse a '<' token.
621  virtual ParseResult parseLess() = 0;
622 
623  /// Parse a '<' token if present.
624  virtual ParseResult parseOptionalLess() = 0;
625 
626  /// Parse a '>' token.
627  virtual ParseResult parseGreater() = 0;
628 
629  /// Parse a '>' token if present.
630  virtual ParseResult parseOptionalGreater() = 0;
631 
632  /// Parse a '?' token.
633  virtual ParseResult parseQuestion() = 0;
634 
635  /// Parse a '?' token if present.
636  virtual ParseResult parseOptionalQuestion() = 0;
637 
638  /// Parse a '+' token.
639  virtual ParseResult parsePlus() = 0;
640 
641  /// Parse a '+' token if present.
642  virtual ParseResult parseOptionalPlus() = 0;
643 
644  /// Parse a '*' token.
645  virtual ParseResult parseStar() = 0;
646 
647  /// Parse a '*' token if present.
648  virtual ParseResult parseOptionalStar() = 0;
649 
650  /// Parse a '|' token.
651  virtual ParseResult parseVerticalBar() = 0;
652 
653  /// Parse a '|' token if present.
654  virtual ParseResult parseOptionalVerticalBar() = 0;
655 
656  /// Parse a quoted string token.
657  ParseResult parseString(std::string *string) {
658  auto loc = getCurrentLocation();
659  if (parseOptionalString(string))
660  return emitError(loc, "expected string");
661  return success();
662  }
663 
664  /// Parse a quoted string token if present.
665  virtual ParseResult parseOptionalString(std::string *string) = 0;
666 
667  /// Parses a Base64 encoded string of bytes.
668  virtual ParseResult parseBase64Bytes(std::vector<char> *bytes) = 0;
669 
670  /// Parse a `(` token.
671  virtual ParseResult parseLParen() = 0;
672 
673  /// Parse a `(` token if present.
674  virtual ParseResult parseOptionalLParen() = 0;
675 
676  /// Parse a `)` token.
677  virtual ParseResult parseRParen() = 0;
678 
679  /// Parse a `)` token if present.
680  virtual ParseResult parseOptionalRParen() = 0;
681 
682  /// Parse a `[` token.
683  virtual ParseResult parseLSquare() = 0;
684 
685  /// Parse a `[` token if present.
686  virtual ParseResult parseOptionalLSquare() = 0;
687 
688  /// Parse a `]` token.
689  virtual ParseResult parseRSquare() = 0;
690 
691  /// Parse a `]` token if present.
692  virtual ParseResult parseOptionalRSquare() = 0;
693 
694  /// Parse a `...` token.
695  virtual ParseResult parseEllipsis() = 0;
696 
697  /// Parse a `...` token if present;
698  virtual ParseResult parseOptionalEllipsis() = 0;
699 
700  /// Parse a floating point value from the stream.
701  virtual ParseResult parseFloat(double &result) = 0;
702 
703  /// Parse a floating point value into APFloat from the stream.
704  virtual ParseResult parseFloat(const llvm::fltSemantics &semantics,
705  APFloat &result) = 0;
706 
707  /// Parse an integer value from the stream.
708  template <typename IntT>
709  ParseResult parseInteger(IntT &result) {
710  auto loc = getCurrentLocation();
711  OptionalParseResult parseResult = parseOptionalInteger(result);
712  if (!parseResult.has_value())
713  return emitError(loc, "expected integer value");
714  return *parseResult;
715  }
716 
717  /// Parse an optional integer value from the stream.
718  virtual OptionalParseResult parseOptionalInteger(APInt &result) = 0;
719 
720  template <typename IntT>
722  auto loc = getCurrentLocation();
723 
724  // Parse the unsigned variant.
725  APInt uintResult;
726  OptionalParseResult parseResult = parseOptionalInteger(uintResult);
727  if (!parseResult.has_value() || failed(*parseResult))
728  return parseResult;
729 
730  // Try to convert to the provided integer type. sextOrTrunc is correct even
731  // for unsigned types because parseOptionalInteger ensures the sign bit is
732  // zero for non-negated integers.
733  result =
734  (IntT)uintResult.sextOrTrunc(sizeof(IntT) * CHAR_BIT).getLimitedValue();
735  if (APInt(uintResult.getBitWidth(), result) != uintResult)
736  return emitError(loc, "integer value too large");
737  return success();
738  }
739 
740  /// These are the supported delimiters around operand lists and region
741  /// argument lists, used by parseOperandList.
742  enum class Delimiter {
743  /// Zero or more operands with no delimiters.
744  None,
745  /// Parens surrounding zero or more operands.
746  Paren,
747  /// Square brackets surrounding zero or more operands.
748  Square,
749  /// <> brackets surrounding zero or more operands.
750  LessGreater,
751  /// {} brackets surrounding zero or more operands.
752  Braces,
753  /// Parens supporting zero or more operands, or nothing.
755  /// Square brackets supporting zero or more ops, or nothing.
757  /// <> brackets supporting zero or more ops, or nothing.
759  /// {} brackets surrounding zero or more operands, or nothing.
761  };
762 
763  /// Parse a list of comma-separated items with an optional delimiter. If a
764  /// delimiter is provided, then an empty list is allowed. If not, then at
765  /// least one element will be parsed.
766  ///
767  /// contextMessage is an optional message appended to "expected '('" sorts of
768  /// diagnostics when parsing the delimeters.
769  virtual ParseResult
771  function_ref<ParseResult()> parseElementFn,
772  StringRef contextMessage = StringRef()) = 0;
773 
774  /// Parse a comma separated list of elements that must have at least one entry
775  /// in it.
776  ParseResult
777  parseCommaSeparatedList(function_ref<ParseResult()> parseElementFn) {
778  return parseCommaSeparatedList(Delimiter::None, parseElementFn);
779  }
780 
781  //===--------------------------------------------------------------------===//
782  // Keyword Parsing
783  //===--------------------------------------------------------------------===//
784 
785  /// This class represents a StringSwitch like class that is useful for parsing
786  /// expected keywords. On construction, unless a non-empty keyword is
787  /// provided, it invokes `parseKeyword` and processes each of the provided
788  /// cases statements until a match is hit. The provided `ResultT` must be
789  /// assignable from `failure()`.
790  template <typename ResultT = ParseResult>
792  public:
793  KeywordSwitch(AsmParser &parser, StringRef *keyword = nullptr)
794  : parser(parser), loc(parser.getCurrentLocation()) {
795  if (keyword && !keyword->empty())
796  this->keyword = *keyword;
797  else if (failed(parser.parseKeywordOrCompletion(&this->keyword)))
798  result = failure();
799  }
800  /// Case that uses the provided value when true.
801  KeywordSwitch &Case(StringLiteral str, ResultT value) {
802  return Case(str, [&](StringRef, SMLoc) { return std::move(value); });
803  }
804  KeywordSwitch &Default(ResultT value) {
805  return Default([&](StringRef, SMLoc) { return std::move(value); });
806  }
807  /// Case that invokes the provided functor when true. The parameters passed
808  /// to the functor are the keyword, and the location of the keyword (in case
809  /// any errors need to be emitted).
810  template <typename FnT>
811  std::enable_if_t<!std::is_convertible<FnT, ResultT>::value, KeywordSwitch &>
812  Case(StringLiteral str, FnT &&fn) {
813  if (result)
814  return *this;
815 
816  // If the word was empty, record this as a completion.
817  if (keyword.empty())
818  parser.codeCompleteExpectedTokens(str);
819  else if (keyword == str)
820  result.emplace(std::move(fn(keyword, loc)));
821  return *this;
822  }
823  template <typename FnT>
824  std::enable_if_t<!std::is_convertible<FnT, ResultT>::value, KeywordSwitch &>
825  Default(FnT &&fn) {
826  if (!result)
827  result.emplace(fn(keyword, loc));
828  return *this;
829  }
830 
831  /// Returns true if this switch has a value yet.
832  bool hasValue() const { return result.has_value(); }
833 
834  /// Return the result of the switch.
835  [[nodiscard]] operator ResultT() {
836  if (!result)
837  return parser.emitError(loc, "unexpected keyword: ") << keyword;
838  return std::move(*result);
839  }
840 
841  private:
842  /// The parser used to construct this switch.
843  AsmParser &parser;
844 
845  /// The location of the keyword, used to emit errors as necessary.
846  SMLoc loc;
847 
848  /// The parsed keyword itself.
849  StringRef keyword;
850 
851  /// The result of the switch statement or std::nullopt if currently unknown.
852  std::optional<ResultT> result;
853  };
854 
855  /// Parse a given keyword.
856  ParseResult parseKeyword(StringRef keyword) {
857  return parseKeyword(keyword, "");
858  }
859  virtual ParseResult parseKeyword(StringRef keyword, const Twine &msg) = 0;
860 
861  /// Parse a keyword into 'keyword'.
862  ParseResult parseKeyword(StringRef *keyword) {
863  auto loc = getCurrentLocation();
864  if (parseOptionalKeyword(keyword))
865  return emitError(loc, "expected valid keyword");
866  return success();
867  }
868 
869  /// Parse the given keyword if present.
870  virtual ParseResult parseOptionalKeyword(StringRef keyword) = 0;
871 
872  /// Parse a keyword, if present, into 'keyword'.
873  virtual ParseResult parseOptionalKeyword(StringRef *keyword) = 0;
874 
875  /// Parse a keyword, if present, and if one of the 'allowedValues',
876  /// into 'keyword'
877  virtual ParseResult
878  parseOptionalKeyword(StringRef *keyword,
879  ArrayRef<StringRef> allowedValues) = 0;
880 
881  /// Parse a keyword or a quoted string.
882  ParseResult parseKeywordOrString(std::string *result) {
883  if (failed(parseOptionalKeywordOrString(result)))
884  return emitError(getCurrentLocation())
885  << "expected valid keyword or string";
886  return success();
887  }
888 
889  /// Parse an optional keyword or string.
890  virtual ParseResult parseOptionalKeywordOrString(std::string *result) = 0;
891 
892  //===--------------------------------------------------------------------===//
893  // Attribute/Type Parsing
894  //===--------------------------------------------------------------------===//
895 
896  /// Invoke the `getChecked` method of the given Attribute or Type class, using
897  /// the provided location to emit errors in the case of failure. Note that
898  /// unlike `OpBuilder::getType`, this method does not implicitly insert a
899  /// context parameter.
900  template <typename T, typename... ParamsT>
901  auto getChecked(SMLoc loc, ParamsT &&...params) {
902  return T::getChecked([&] { return emitError(loc); },
903  std::forward<ParamsT>(params)...);
904  }
905  /// A variant of `getChecked` that uses the result of `getNameLoc` to emit
906  /// errors.
907  template <typename T, typename... ParamsT>
908  auto getChecked(ParamsT &&...params) {
909  return T::getChecked([&] { return emitError(getNameLoc()); },
910  std::forward<ParamsT>(params)...);
911  }
912 
913  //===--------------------------------------------------------------------===//
914  // Attribute Parsing
915  //===--------------------------------------------------------------------===//
916 
917  /// Parse an arbitrary attribute of a given type and return it in result.
918  virtual ParseResult parseAttribute(Attribute &result, Type type = {}) = 0;
919 
920  /// Parse a custom attribute with the provided callback, unless the next
921  /// token is `#`, in which case the generic parser is invoked.
922  virtual ParseResult parseCustomAttributeWithFallback(
923  Attribute &result, Type type,
924  function_ref<ParseResult(Attribute &result, Type type)>
925  parseAttribute) = 0;
926 
927  /// Parse an attribute of a specific kind and type.
928  template <typename AttrType>
929  ParseResult parseAttribute(AttrType &result, Type type = {}) {
930  SMLoc loc = getCurrentLocation();
931 
932  // Parse any kind of attribute.
933  Attribute attr;
934  if (parseAttribute(attr, type))
935  return failure();
936 
937  // Check for the right kind of attribute.
938  if (!(result = llvm::dyn_cast<AttrType>(attr)))
939  return emitError(loc, "invalid kind of attribute specified");
940 
941  return success();
942  }
943 
944  /// Parse an arbitrary attribute and return it in result. This also adds the
945  /// attribute to the specified attribute list with the specified name.
946  ParseResult parseAttribute(Attribute &result, StringRef attrName,
947  NamedAttrList &attrs) {
948  return parseAttribute(result, Type(), attrName, attrs);
949  }
950 
951  /// Parse an attribute of a specific kind and type.
952  template <typename AttrType>
953  ParseResult parseAttribute(AttrType &result, StringRef attrName,
954  NamedAttrList &attrs) {
955  return parseAttribute(result, Type(), attrName, attrs);
956  }
957 
958  /// Parse an arbitrary attribute of a given type and populate it in `result`.
959  /// This also adds the attribute to the specified attribute list with the
960  /// specified name.
961  template <typename AttrType>
962  ParseResult parseAttribute(AttrType &result, Type type, StringRef attrName,
963  NamedAttrList &attrs) {
964  SMLoc loc = getCurrentLocation();
965 
966  // Parse any kind of attribute.
967  Attribute attr;
968  if (parseAttribute(attr, type))
969  return failure();
970 
971  // Check for the right kind of attribute.
972  result = llvm::dyn_cast<AttrType>(attr);
973  if (!result)
974  return emitError(loc, "invalid kind of attribute specified");
975 
976  attrs.append(attrName, result);
977  return success();
978  }
979 
980  /// Trait to check if `AttrType` provides a `parse` method.
981  template <typename AttrType>
982  using has_parse_method = decltype(AttrType::parse(std::declval<AsmParser &>(),
983  std::declval<Type>()));
984  template <typename AttrType>
985  using detect_has_parse_method = llvm::is_detected<has_parse_method, AttrType>;
986 
987  /// Parse a custom attribute of a given type unless the next token is `#`, in
988  /// which case the generic parser is invoked. The parsed attribute is
989  /// populated in `result` and also added to the specified attribute list with
990  /// the specified name.
991  template <typename AttrType>
992  std::enable_if_t<detect_has_parse_method<AttrType>::value, ParseResult>
993  parseCustomAttributeWithFallback(AttrType &result, Type type,
994  StringRef attrName, NamedAttrList &attrs) {
995  SMLoc loc = getCurrentLocation();
996 
997  // Parse any kind of attribute.
998  Attribute attr;
1000  attr, type, [&](Attribute &result, Type type) -> ParseResult {
1001  result = AttrType::parse(*this, type);
1002  if (!result)
1003  return failure();
1004  return success();
1005  }))
1006  return failure();
1007 
1008  // Check for the right kind of attribute.
1009  result = llvm::dyn_cast<AttrType>(attr);
1010  if (!result)
1011  return emitError(loc, "invalid kind of attribute specified");
1012 
1013  attrs.append(attrName, result);
1014  return success();
1015  }
1016 
1017  /// SFINAE parsing method for Attribute that don't implement a parse method.
1018  template <typename AttrType>
1019  std::enable_if_t<!detect_has_parse_method<AttrType>::value, ParseResult>
1020  parseCustomAttributeWithFallback(AttrType &result, Type type,
1021  StringRef attrName, NamedAttrList &attrs) {
1022  return parseAttribute(result, type, attrName, attrs);
1023  }
1024 
1025  /// Parse a custom attribute of a given type unless the next token is `#`, in
1026  /// which case the generic parser is invoked. The parsed attribute is
1027  /// populated in `result`.
1028  template <typename AttrType>
1029  std::enable_if_t<detect_has_parse_method<AttrType>::value, ParseResult>
1030  parseCustomAttributeWithFallback(AttrType &result, Type type = {}) {
1031  SMLoc loc = getCurrentLocation();
1032 
1033  // Parse any kind of attribute.
1034  Attribute attr;
1036  attr, type, [&](Attribute &result, Type type) -> ParseResult {
1037  result = AttrType::parse(*this, type);
1038  return success(!!result);
1039  }))
1040  return failure();
1041 
1042  // Check for the right kind of attribute.
1043  result = llvm::dyn_cast<AttrType>(attr);
1044  if (!result)
1045  return emitError(loc, "invalid kind of attribute specified");
1046  return success();
1047  }
1048 
1049  /// SFINAE parsing method for Attribute that don't implement a parse method.
1050  template <typename AttrType>
1051  std::enable_if_t<!detect_has_parse_method<AttrType>::value, ParseResult>
1052  parseCustomAttributeWithFallback(AttrType &result, Type type = {}) {
1053  return parseAttribute(result, type);
1054  }
1055 
1056  /// Parse an arbitrary optional attribute of a given type and return it in
1057  /// result.
1059  Type type = {}) = 0;
1060 
1061  /// Parse an optional array attribute and return it in result.
1062  virtual OptionalParseResult parseOptionalAttribute(ArrayAttr &result,
1063  Type type = {}) = 0;
1064 
1065  /// Parse an optional string attribute and return it in result.
1066  virtual OptionalParseResult parseOptionalAttribute(StringAttr &result,
1067  Type type = {}) = 0;
1068 
1069  /// Parse an optional symbol ref attribute and return it in result.
1070  virtual OptionalParseResult parseOptionalAttribute(SymbolRefAttr &result,
1071  Type type = {}) = 0;
1072 
1073  /// Parse an optional attribute of a specific type and add it to the list with
1074  /// the specified name.
1075  template <typename AttrType>
1077  StringRef attrName,
1078  NamedAttrList &attrs) {
1079  return parseOptionalAttribute(result, Type(), attrName, attrs);
1080  }
1081 
1082  /// Parse an optional attribute of a specific type and add it to the list with
1083  /// the specified name.
1084  template <typename AttrType>
1086  StringRef attrName,
1087  NamedAttrList &attrs) {
1088  OptionalParseResult parseResult = parseOptionalAttribute(result, type);
1089  if (parseResult.has_value() && succeeded(*parseResult))
1090  attrs.append(attrName, result);
1091  return parseResult;
1092  }
1093 
1094  /// Parse a named dictionary into 'result' if it is present.
1095  virtual ParseResult parseOptionalAttrDict(NamedAttrList &result) = 0;
1096 
1097  /// Parse a named dictionary into 'result' if the `attributes` keyword is
1098  /// present.
1099  virtual ParseResult
1101 
1102  /// Parse an affine map instance into 'map'.
1103  virtual ParseResult parseAffineMap(AffineMap &map) = 0;
1104 
1105  /// Parse an affine expr instance into 'expr' using the already computed
1106  /// mapping from symbols to affine expressions in 'symbolSet'.
1107  virtual ParseResult
1108  parseAffineExpr(ArrayRef<std::pair<StringRef, AffineExpr>> symbolSet,
1109  AffineExpr &expr) = 0;
1110 
1111  /// Parse an integer set instance into 'set'.
1112  virtual ParseResult parseIntegerSet(IntegerSet &set) = 0;
1113 
1114  //===--------------------------------------------------------------------===//
1115  // Identifier Parsing
1116  //===--------------------------------------------------------------------===//
1117 
1118  /// Parse an @-identifier and store it (without the '@' symbol) in a string
1119  /// attribute.
1120  ParseResult parseSymbolName(StringAttr &result) {
1121  if (failed(parseOptionalSymbolName(result)))
1122  return emitError(getCurrentLocation())
1123  << "expected valid '@'-identifier for symbol name";
1124  return success();
1125  }
1126 
1127  /// Parse an @-identifier and store it (without the '@' symbol) in a string
1128  /// attribute named 'attrName'.
1129  ParseResult parseSymbolName(StringAttr &result, StringRef attrName,
1130  NamedAttrList &attrs) {
1131  if (parseSymbolName(result))
1132  return failure();
1133  attrs.append(attrName, result);
1134  return success();
1135  }
1136 
1137  /// Parse an optional @-identifier and store it (without the '@' symbol) in a
1138  /// string attribute.
1139  virtual ParseResult parseOptionalSymbolName(StringAttr &result) = 0;
1140 
1141  /// Parse an optional @-identifier and store it (without the '@' symbol) in a
1142  /// string attribute named 'attrName'.
1143  ParseResult parseOptionalSymbolName(StringAttr &result, StringRef attrName,
1144  NamedAttrList &attrs) {
1145  if (succeeded(parseOptionalSymbolName(result))) {
1146  attrs.append(attrName, result);
1147  return success();
1148  }
1149  return failure();
1150  }
1151 
1152  //===--------------------------------------------------------------------===//
1153  // Resource Parsing
1154  //===--------------------------------------------------------------------===//
1155 
1156  /// Parse a handle to a resource within the assembly format.
1157  template <typename ResourceT>
1158  FailureOr<ResourceT> parseResourceHandle() {
1159  SMLoc handleLoc = getCurrentLocation();
1160 
1161  // Try to load the dialect that owns the handle.
1162  auto *dialect =
1163  getContext()->getOrLoadDialect<typename ResourceT::Dialect>();
1164  if (!dialect) {
1165  return emitError(handleLoc)
1166  << "dialect '" << ResourceT::Dialect::getDialectNamespace()
1167  << "' is unknown";
1168  }
1169 
1170  FailureOr<AsmDialectResourceHandle> handle = parseResourceHandle(dialect);
1171  if (failed(handle))
1172  return failure();
1173  if (auto *result = dyn_cast<ResourceT>(&*handle))
1174  return std::move(*result);
1175  return emitError(handleLoc) << "provided resource handle differs from the "
1176  "expected resource type";
1177  }
1178 
1179  //===--------------------------------------------------------------------===//
1180  // Type Parsing
1181  //===--------------------------------------------------------------------===//
1182 
1183  /// Parse a type.
1184  virtual ParseResult parseType(Type &result) = 0;
1185 
1186  /// Parse a custom type with the provided callback, unless the next
1187  /// token is `#`, in which case the generic parser is invoked.
1188  virtual ParseResult parseCustomTypeWithFallback(
1189  Type &result, function_ref<ParseResult(Type &result)> parseType) = 0;
1190 
1191  /// Parse an optional type.
1193 
1194  /// Parse a type of a specific type.
1195  template <typename TypeT>
1196  ParseResult parseType(TypeT &result) {
1197  SMLoc loc = getCurrentLocation();
1198 
1199  // Parse any kind of type.
1200  Type type;
1201  if (parseType(type))
1202  return failure();
1203 
1204  // Check for the right kind of type.
1205  result = llvm::dyn_cast<TypeT>(type);
1206  if (!result)
1207  return emitError(loc, "invalid kind of type specified");
1208 
1209  return success();
1210  }
1211 
1212  /// Trait to check if `TypeT` provides a `parse` method.
1213  template <typename TypeT>
1215  decltype(TypeT::parse(std::declval<AsmParser &>()));
1216  template <typename TypeT>
1218  llvm::is_detected<type_has_parse_method, TypeT>;
1219 
1220  /// Parse a custom Type of a given type unless the next token is `#`, in
1221  /// which case the generic parser is invoked. The parsed Type is
1222  /// populated in `result`.
1223  template <typename TypeT>
1224  std::enable_if_t<detect_type_has_parse_method<TypeT>::value, ParseResult>
1226  SMLoc loc = getCurrentLocation();
1227 
1228  // Parse any kind of Type.
1229  Type type;
1230  if (parseCustomTypeWithFallback(type, [&](Type &result) -> ParseResult {
1231  result = TypeT::parse(*this);
1232  return success(!!result);
1233  }))
1234  return failure();
1235 
1236  // Check for the right kind of Type.
1237  result = llvm::dyn_cast<TypeT>(type);
1238  if (!result)
1239  return emitError(loc, "invalid kind of Type specified");
1240  return success();
1241  }
1242 
1243  /// SFINAE parsing method for Type that don't implement a parse method.
1244  template <typename TypeT>
1245  std::enable_if_t<!detect_type_has_parse_method<TypeT>::value, ParseResult>
1247  return parseType(result);
1248  }
1249 
1250  /// Parse a type list.
1251  ParseResult parseTypeList(SmallVectorImpl<Type> &result);
1252 
1253  /// Parse an arrow followed by a type list.
1254  virtual ParseResult parseArrowTypeList(SmallVectorImpl<Type> &result) = 0;
1255 
1256  /// Parse an optional arrow followed by a type list.
1257  virtual ParseResult
1259 
1260  /// Parse a colon followed by a type.
1261  virtual ParseResult parseColonType(Type &result) = 0;
1262 
1263  /// Parse a colon followed by a type of a specific kind, e.g. a FunctionType.
1264  template <typename TypeType>
1265  ParseResult parseColonType(TypeType &result) {
1266  SMLoc loc = getCurrentLocation();
1267 
1268  // Parse any kind of type.
1269  Type type;
1270  if (parseColonType(type))
1271  return failure();
1272 
1273  // Check for the right kind of type.
1274  result = llvm::dyn_cast<TypeType>(type);
1275  if (!result)
1276  return emitError(loc, "invalid kind of type specified");
1277 
1278  return success();
1279  }
1280 
1281  /// Parse a colon followed by a type list, which must have at least one type.
1282  virtual ParseResult parseColonTypeList(SmallVectorImpl<Type> &result) = 0;
1283 
1284  /// Parse an optional colon followed by a type list, which if present must
1285  /// have at least one type.
1286  virtual ParseResult
1288 
1289  /// Parse a keyword followed by a type.
1290  ParseResult parseKeywordType(const char *keyword, Type &result) {
1291  return failure(parseKeyword(keyword) || parseType(result));
1292  }
1293 
1294  /// Add the specified type to the end of the specified type list and return
1295  /// success. This is a helper designed to allow parse methods to be simple
1296  /// and chain through || operators.
1297  ParseResult addTypeToList(Type type, SmallVectorImpl<Type> &result) {
1298  result.push_back(type);
1299  return success();
1300  }
1301 
1302  /// Add the specified types to the end of the specified type list and return
1303  /// success. This is a helper designed to allow parse methods to be simple
1304  /// and chain through || operators.
1305  ParseResult addTypesToList(ArrayRef<Type> types,
1306  SmallVectorImpl<Type> &result) {
1307  result.append(types.begin(), types.end());
1308  return success();
1309  }
1310 
1311  /// Parse a dimension list of a tensor or memref type. This populates the
1312  /// dimension list, using ShapedType::kDynamic for the `?` dimensions if
1313  /// `allowDynamic` is set and errors out on `?` otherwise. Parsing the
1314  /// trailing `x` is configurable.
1315  ///
1316  /// dimension-list ::= eps | dimension (`x` dimension)*
1317  /// dimension-list-with-trailing-x ::= (dimension `x`)*
1318  /// dimension ::= `?` | decimal-literal
1319  ///
1320  /// When `allowDynamic` is not set, this is used to parse:
1321  ///
1322  /// static-dimension-list ::= eps | decimal-literal (`x` decimal-literal)*
1323  /// static-dimension-list-with-trailing-x ::= (dimension `x`)*
1324  virtual ParseResult parseDimensionList(SmallVectorImpl<int64_t> &dimensions,
1325  bool allowDynamic = true,
1326  bool withTrailingX = true) = 0;
1327 
1328  /// Parse an 'x' token in a dimension list, handling the case where the x is
1329  /// juxtaposed with an element type, as in "xf32", leaving the "f32" as the
1330  /// next token.
1331  virtual ParseResult parseXInDimensionList() = 0;
1332 
1333  /// Class used to automatically end a cyclic region on destruction.
1335  public:
1336  explicit CyclicParseReset(AsmParser *parser) : parser(parser) {}
1337 
1339  if (parser)
1340  parser->popCyclicParsing();
1341  }
1342 
1346  : parser(std::exchange(rhs.parser, nullptr)) {}
1348  parser = std::exchange(rhs.parser, nullptr);
1349  return *this;
1350  }
1351 
1352  private:
1353  AsmParser *parser;
1354  };
1355 
1356  /// Attempts to start a cyclic parsing region for `attrOrType`.
1357  /// A cyclic parsing region starts with this call and ends with the
1358  /// destruction of the returned `CyclicParseReset`. During this time,
1359  /// calling `tryStartCyclicParse` with the same attribute in any parser
1360  /// will lead to returning failure.
1361  ///
1362  /// This makes it possible to parse cyclic attributes or types by parsing a
1363  /// short from if nested within itself.
1364  template <class AttrOrTypeT>
1365  FailureOr<CyclicParseReset> tryStartCyclicParse(AttrOrTypeT attrOrType) {
1366  static_assert(
1367  std::is_base_of_v<AttributeTrait::IsMutable<AttrOrTypeT>,
1368  AttrOrTypeT> ||
1369  std::is_base_of_v<TypeTrait::IsMutable<AttrOrTypeT>, AttrOrTypeT>,
1370  "Only mutable attributes or types can be cyclic");
1371  if (failed(pushCyclicParsing(attrOrType.getAsOpaquePointer())))
1372  return failure();
1373 
1374  return CyclicParseReset(this);
1375  }
1376 
1377 protected:
1378  /// Parse a handle to a resource within the assembly format for the given
1379  /// dialect.
1380  virtual FailureOr<AsmDialectResourceHandle>
1382 
1383  /// Pushes a new attribute or type in the form of a type erased pointer
1384  /// into an internal set.
1385  /// Returns success if the type or attribute was inserted in the set or
1386  /// failure if it was already contained.
1387  virtual LogicalResult pushCyclicParsing(const void *opaquePointer) = 0;
1388 
1389  /// Removes the element that was last inserted with a successful call to
1390  /// `pushCyclicParsing`. There must be exactly one `popCyclicParsing` call
1391  /// in reverse order of all successful `pushCyclicParsing`.
1392  virtual void popCyclicParsing() = 0;
1393 
1394  //===--------------------------------------------------------------------===//
1395  // Code Completion
1396  //===--------------------------------------------------------------------===//
1397 
1398  /// Parse a keyword, or an empty string if the current location signals a code
1399  /// completion.
1400  virtual ParseResult parseKeywordOrCompletion(StringRef *keyword) = 0;
1401 
1402  /// Signal the code completion of a set of expected tokens.
1404 
1405 private:
1406  AsmParser(const AsmParser &) = delete;
1407  void operator=(const AsmParser &) = delete;
1408 };
1409 
1410 //===----------------------------------------------------------------------===//
1411 // OpAsmParser
1412 //===----------------------------------------------------------------------===//
1413 
1414 /// The OpAsmParser has methods for interacting with the asm parser: parsing
1415 /// things from it, emitting errors etc. It has an intentionally high-level API
1416 /// that is designed to reduce/constrain syntax innovation in individual
1417 /// operations.
1418 ///
1419 /// For example, consider an op like this:
1420 ///
1421 /// %x = load %p[%1, %2] : memref<...>
1422 ///
1423 /// The "%x = load" tokens are already parsed and therefore invisible to the
1424 /// custom op parser. This can be supported by calling `parseOperandList` to
1425 /// parse the %p, then calling `parseOperandList` with a `SquareDelimiter` to
1426 /// parse the indices, then calling `parseColonTypeList` to parse the result
1427 /// type.
1428 ///
1429 class OpAsmParser : public AsmParser {
1430 public:
1431  using AsmParser::AsmParser;
1432  ~OpAsmParser() override;
1433 
1434  /// Parse a loc(...) specifier if present, filling in result if so.
1435  /// Location for BlockArgument and Operation may be deferred with an alias, in
1436  /// which case an OpaqueLoc is set and will be resolved when parsing
1437  /// completes.
1438  virtual ParseResult
1439  parseOptionalLocationSpecifier(std::optional<Location> &result) = 0;
1440 
1441  /// Return the name of the specified result in the specified syntax, as well
1442  /// as the sub-element in the name. It returns an empty string and ~0U for
1443  /// invalid result numbers. For example, in this operation:
1444  ///
1445  /// %x, %y:2, %z = foo.op
1446  ///
1447  /// getResultName(0) == {"x", 0 }
1448  /// getResultName(1) == {"y", 0 }
1449  /// getResultName(2) == {"y", 1 }
1450  /// getResultName(3) == {"z", 0 }
1451  /// getResultName(4) == {"", ~0U }
1452  virtual std::pair<StringRef, unsigned>
1453  getResultName(unsigned resultNo) const = 0;
1454 
1455  /// Return the number of declared SSA results. This returns 4 for the foo.op
1456  /// example in the comment for `getResultName`.
1457  virtual size_t getNumResults() const = 0;
1458 
1459  // These methods emit an error and return failure or success. This allows
1460  // these to be chained together into a linear sequence of || expressions in
1461  // many cases.
1462 
1463  /// Parse an operation in its generic form.
1464  /// The parsed operation is parsed in the current context and inserted in the
1465  /// provided block and insertion point. The results produced by this operation
1466  /// aren't mapped to any named value in the parser. Returns nullptr on
1467  /// failure.
1468  virtual Operation *parseGenericOperation(Block *insertBlock,
1469  Block::iterator insertPt) = 0;
1470 
1471  /// Parse the name of an operation, in the custom form. On success, return a
1472  /// an object of type 'OperationName'. Otherwise, failure is returned.
1473  virtual FailureOr<OperationName> parseCustomOperationName() = 0;
1474 
1475  //===--------------------------------------------------------------------===//
1476  // Operand Parsing
1477  //===--------------------------------------------------------------------===//
1478 
1479  /// This is the representation of an operand reference.
1481  SMLoc location; // Location of the token.
1482  StringRef name; // Value name, e.g. %42 or %abc
1483  unsigned number; // Number, e.g. 12 for an operand like %xyz#12
1484  };
1485 
1486  /// Parse different components, viz., use-info of operand(s), successor(s),
1487  /// region(s), attribute(s) and function-type, of the generic form of an
1488  /// operation instance and populate the input operation-state 'result' with
1489  /// those components. If any of the components is explicitly provided, then
1490  /// skip parsing that component.
1492  OperationState &result,
1493  std::optional<ArrayRef<UnresolvedOperand>> parsedOperandType =
1494  std::nullopt,
1495  std::optional<ArrayRef<Block *>> parsedSuccessors = std::nullopt,
1496  std::optional<MutableArrayRef<std::unique_ptr<Region>>> parsedRegions =
1497  std::nullopt,
1498  std::optional<ArrayRef<NamedAttribute>> parsedAttributes = std::nullopt,
1499  std::optional<Attribute> parsedPropertiesAttribute = std::nullopt,
1500  std::optional<FunctionType> parsedFnType = std::nullopt) = 0;
1501 
1502  /// Parse a single SSA value operand name along with a result number if
1503  /// `allowResultNumber` is true.
1504  virtual ParseResult parseOperand(UnresolvedOperand &result,
1505  bool allowResultNumber = true) = 0;
1506 
1507  /// Parse a single operand if present.
1508  virtual OptionalParseResult
1510  bool allowResultNumber = true) = 0;
1511 
1512  /// Parse zero or more SSA comma-separated operand references with a specified
1513  /// surrounding delimiter, and an optional required operand count.
1514  virtual ParseResult
1516  Delimiter delimiter = Delimiter::None,
1517  bool allowResultNumber = true,
1518  int requiredOperandCount = -1) = 0;
1519 
1520  /// Parse a specified number of comma separated operands.
1522  int requiredOperandCount,
1523  Delimiter delimiter = Delimiter::None) {
1524  return parseOperandList(result, delimiter,
1525  /*allowResultNumber=*/true, requiredOperandCount);
1526  }
1527 
1528  /// Parse zero or more trailing SSA comma-separated trailing operand
1529  /// references with a specified surrounding delimiter, and an optional
1530  /// required operand count. A leading comma is expected before the
1531  /// operands.
1532  ParseResult
1534  Delimiter delimiter = Delimiter::None) {
1535  if (failed(parseOptionalComma()))
1536  return success(); // The comma is optional.
1537  return parseOperandList(result, delimiter);
1538  }
1539 
1540  /// Resolve an operand to an SSA value, emitting an error on failure.
1541  virtual ParseResult resolveOperand(const UnresolvedOperand &operand,
1542  Type type,
1543  SmallVectorImpl<Value> &result) = 0;
1544 
1545  /// Resolve a list of operands to SSA values, emitting an error on failure, or
1546  /// appending the results to the list on success. This method should be used
1547  /// when all operands have the same type.
1548  template <typename Operands = ArrayRef<UnresolvedOperand>>
1549  ParseResult resolveOperands(Operands &&operands, Type type,
1550  SmallVectorImpl<Value> &result) {
1551  for (const UnresolvedOperand &operand : operands)
1552  if (resolveOperand(operand, type, result))
1553  return failure();
1554  return success();
1555  }
1556  template <typename Operands = ArrayRef<UnresolvedOperand>>
1557  ParseResult resolveOperands(Operands &&operands, Type type, SMLoc loc,
1558  SmallVectorImpl<Value> &result) {
1559  return resolveOperands(std::forward<Operands>(operands), type, result);
1560  }
1561 
1562  /// Resolve a list of operands and a list of operand types to SSA values,
1563  /// emitting an error and returning failure, or appending the results
1564  /// to the list on success.
1565  template <typename Operands = ArrayRef<UnresolvedOperand>,
1566  typename Types = ArrayRef<Type>>
1567  std::enable_if_t<!std::is_convertible<Types, Type>::value, ParseResult>
1568  resolveOperands(Operands &&operands, Types &&types, SMLoc loc,
1569  SmallVectorImpl<Value> &result) {
1570  size_t operandSize = llvm::range_size(operands);
1571  size_t typeSize = llvm::range_size(types);
1572  if (operandSize != typeSize)
1573  return emitError(loc)
1574  << operandSize << " operands present, but expected " << typeSize;
1575 
1576  for (auto [operand, type] : llvm::zip_equal(operands, types))
1577  if (resolveOperand(operand, type, result))
1578  return failure();
1579  return success();
1580  }
1581 
1582  /// Parses an affine map attribute where dims and symbols are SSA operands.
1583  /// Operand values must come from single-result sources, and be valid
1584  /// dimensions/symbol identifiers according to mlir::isValidDim/Symbol.
1585  virtual ParseResult
1587  Attribute &map, StringRef attrName,
1588  NamedAttrList &attrs,
1589  Delimiter delimiter = Delimiter::Square) = 0;
1590 
1591  /// Parses an affine expression where dims and symbols are SSA operands.
1592  /// Operand values must come from single-result sources, and be valid
1593  /// dimensions/symbol identifiers according to mlir::isValidDim/Symbol.
1594  virtual ParseResult
1596  SmallVectorImpl<UnresolvedOperand> &symbOperands,
1597  AffineExpr &expr) = 0;
1598 
1599  //===--------------------------------------------------------------------===//
1600  // Argument Parsing
1601  //===--------------------------------------------------------------------===//
1602 
1603  struct Argument {
1604  UnresolvedOperand ssaName; // SourceLoc, SSA name, result #.
1605  Type type; // Type.
1606  DictionaryAttr attrs; // Attributes if present.
1607  std::optional<Location> sourceLoc; // Source location specifier if present.
1608  };
1609 
1610  /// Parse a single argument with the following syntax:
1611  ///
1612  /// `%ssaName : !type { optionalAttrDict} loc(optionalSourceLoc)`
1613  ///
1614  /// If `allowType` is false or `allowAttrs` are false then the respective
1615  /// parts of the grammar are not parsed.
1616  virtual ParseResult parseArgument(Argument &result, bool allowType = false,
1617  bool allowAttrs = false) = 0;
1618 
1619  /// Parse a single argument if present.
1620  virtual OptionalParseResult
1621  parseOptionalArgument(Argument &result, bool allowType = false,
1622  bool allowAttrs = false) = 0;
1623 
1624  /// Parse zero or more arguments with a specified surrounding delimiter.
1625  virtual ParseResult parseArgumentList(SmallVectorImpl<Argument> &result,
1626  Delimiter delimiter = Delimiter::None,
1627  bool allowType = false,
1628  bool allowAttrs = false) = 0;
1629 
1630  //===--------------------------------------------------------------------===//
1631  // Region Parsing
1632  //===--------------------------------------------------------------------===//
1633 
1634  /// Parses a region. Any parsed blocks are appended to 'region' and must be
1635  /// moved to the op regions after the op is created. The first block of the
1636  /// region takes 'arguments'.
1637  ///
1638  /// If 'enableNameShadowing' is set to true, the argument names are allowed to
1639  /// shadow the names of other existing SSA values defined above the region
1640  /// scope. 'enableNameShadowing' can only be set to true for regions attached
1641  /// to operations that are 'IsolatedFromAbove'.
1642  virtual ParseResult parseRegion(Region &region,
1643  ArrayRef<Argument> arguments = {},
1644  bool enableNameShadowing = false) = 0;
1645 
1646  /// Parses a region if present.
1647  virtual OptionalParseResult
1649  bool enableNameShadowing = false) = 0;
1650 
1651  /// Parses a region if present. If the region is present, a new region is
1652  /// allocated and placed in `region`. If no region is present or on failure,
1653  /// `region` remains untouched.
1654  virtual OptionalParseResult
1655  parseOptionalRegion(std::unique_ptr<Region> &region,
1656  ArrayRef<Argument> arguments = {},
1657  bool enableNameShadowing = false) = 0;
1658 
1659  //===--------------------------------------------------------------------===//
1660  // Successor Parsing
1661  //===--------------------------------------------------------------------===//
1662 
1663  /// Parse a single operation successor.
1664  virtual ParseResult parseSuccessor(Block *&dest) = 0;
1665 
1666  /// Parse an optional operation successor.
1668 
1669  /// Parse a single operation successor and its operand list.
1670  virtual ParseResult
1672 
1673  //===--------------------------------------------------------------------===//
1674  // Type Parsing
1675  //===--------------------------------------------------------------------===//
1676 
1677  /// Parse a list of assignments of the form
1678  /// (%x1 = %y1, %x2 = %y2, ...)
1682  if (!result.has_value())
1683  return emitError(getCurrentLocation(), "expected '('");
1684  return result.value();
1685  }
1686 
1687  virtual OptionalParseResult
1690 };
1691 
1692 //===--------------------------------------------------------------------===//
1693 // Dialect OpAsm interface.
1694 //===--------------------------------------------------------------------===//
1695 
1696 /// A functor used to set the name of the start of a result group of an
1697 /// operation. See 'getAsmResultNames' below for more details.
1698 using OpAsmSetValueNameFn = function_ref<void(Value, StringRef)>;
1699 
1700 /// A functor used to set the name of blocks in regions directly nested under
1701 /// an operation.
1702 using OpAsmSetBlockNameFn = function_ref<void(Block *, StringRef)>;
1703 
1705  : public DialectInterface::Base<OpAsmDialectInterface> {
1706 public:
1707  OpAsmDialectInterface(Dialect *dialect) : Base(dialect) {}
1708 
1709  //===------------------------------------------------------------------===//
1710  // Aliases
1711  //===------------------------------------------------------------------===//
1712 
1713  /// Holds the result of `getAlias` hook call.
1714  enum class AliasResult {
1715  /// The object (type or attribute) is not supported by the hook
1716  /// and an alias was not provided.
1717  NoAlias,
1718  /// An alias was provided, but it might be overriden by other hook.
1720  /// An alias was provided and it should be used
1721  /// (no other hooks will be checked).
1722  FinalAlias
1723  };
1724 
1725  /// Hooks for getting an alias identifier alias for a given symbol, that is
1726  /// not necessarily a part of this dialect. The identifier is used in place of
1727  /// the symbol when printing textual IR. These aliases must not contain `.` or
1728  /// end with a numeric digit([0-9]+).
1729  virtual AliasResult getAlias(Attribute attr, raw_ostream &os) const {
1730  return AliasResult::NoAlias;
1731  }
1732  virtual AliasResult getAlias(Type type, raw_ostream &os) const {
1733  return AliasResult::NoAlias;
1734  }
1735 
1736  //===--------------------------------------------------------------------===//
1737  // Resources
1738  //===--------------------------------------------------------------------===//
1739 
1740  /// Declare a resource with the given key, returning a handle to use for any
1741  /// references of this resource key within the IR during parsing. The result
1742  /// of `getResourceKey` on the returned handle is permitted to be different
1743  /// than `key`.
1744  virtual FailureOr<AsmDialectResourceHandle>
1745  declareResource(StringRef key) const {
1746  return failure();
1747  }
1748 
1749  /// Return a key to use for the given resource. This key should uniquely
1750  /// identify this resource within the dialect.
1751  virtual std::string
1753  llvm_unreachable(
1754  "Dialect must implement `getResourceKey` when defining resources");
1755  }
1756 
1757  /// Hook for parsing resource entries. Returns failure if the entry was not
1758  /// valid, or could otherwise not be processed correctly. Any necessary errors
1759  /// can be emitted via the provided entry.
1760  virtual LogicalResult parseResource(AsmParsedResourceEntry &entry) const;
1761 
1762  /// Hook for building resources to use during printing. The given `op` may be
1763  /// inspected to help determine what information to include.
1764  /// `referencedResources` contains all of the resources detected when printing
1765  /// 'op'.
1766  virtual void
1768  const SetVector<AsmDialectResourceHandle> &referencedResources,
1769  AsmResourceBuilder &builder) const {}
1770 };
1771 
1772 //===--------------------------------------------------------------------===//
1773 // Custom printers and parsers.
1774 //===--------------------------------------------------------------------===//
1775 
1776 // Handles custom<DimensionList>(...) in TableGen.
1777 void printDimensionList(OpAsmPrinter &printer, Operation *op,
1778  ArrayRef<int64_t> dimensions);
1779 ParseResult parseDimensionList(OpAsmParser &parser,
1780  DenseI64ArrayAttr &dimensions);
1781 
1782 } // namespace mlir
1783 
1784 //===--------------------------------------------------------------------===//
1785 // Operation OpAsm interface.
1786 //===--------------------------------------------------------------------===//
1787 
1788 /// The OpAsmOpInterface, see OpAsmInterface.td for more details.
1789 #include "mlir/IR/OpAsmInterface.h.inc"
1790 
1791 namespace llvm {
1792 template <>
1793 struct DenseMapInfo<mlir::AsmDialectResourceHandle> {
1797  }
1801  }
1802  static unsigned getHashValue(const mlir::AsmDialectResourceHandle &handle) {
1804  }
1805  static bool isEqual(const mlir::AsmDialectResourceHandle &lhs,
1806  const mlir::AsmDialectResourceHandle &rhs) {
1807  return lhs.getResource() == rhs.getResource();
1808  }
1809 };
1810 } // namespace llvm
1811 
1812 #endif
static void print(spirv::VerCapExtAttr triple, DialectAsmPrinter &printer)
Base type for affine expression.
Definition: AffineExpr.h:68
A multi-dimensional affine map Affine map's are immutable like Type's, and they are uniqued.
Definition: AffineMap.h:46
This class represents a CRTP base class for dialect resource handles.
const ResourceT * getResource() const
AsmDialectResourceHandleBase(AsmDialectResourceHandle handle)
ResourceT * getResource()
Return the resource referenced by this handle.
static bool classof(const AsmDialectResourceHandle *handle)
Support llvm style casting.
AsmDialectResourceHandleBase(ResourceT *resource, DialectT *dialect)
Construct a handle from a pointer to the resource.
DialectT * getDialect() const
Return the dialect that owns the resource.
This class represents an opaque handle to a dialect resource entry.
Dialect * getDialect() const
Return the dialect that owns the resource.
TypeID getTypeID() const
Return the type ID of the resource.
bool operator==(const AsmDialectResourceHandle &other) const
AsmDialectResourceHandle(void *resource, TypeID resourceID, Dialect *dialect)
void * getResource() const
Return an opaque pointer to the referenced resource.
This class represents a single parsed resource entry.
Definition: AsmState.h:283
Class used to automatically end a cyclic region on destruction.
CyclicParseReset & operator=(CyclicParseReset &&rhs)
CyclicParseReset & operator=(const CyclicParseReset &)=delete
CyclicParseReset(const CyclicParseReset &)=delete
CyclicParseReset(CyclicParseReset &&rhs)
This class represents a StringSwitch like class that is useful for parsing expected keywords.
std::enable_if_t<!std::is_convertible< FnT, ResultT >::value, KeywordSwitch & > Default(FnT &&fn)
KeywordSwitch & Case(StringLiteral str, ResultT value)
Case that uses the provided value when true.
bool hasValue() const
Returns true if this switch has a value yet.
std::enable_if_t<!std::is_convertible< FnT, ResultT >::value, KeywordSwitch & > Case(StringLiteral str, FnT &&fn)
Case that invokes the provided functor when true.
KeywordSwitch & Default(ResultT value)
KeywordSwitch(AsmParser &parser, StringRef *keyword=nullptr)
This base class exposes generic asm parser hooks, usable across the various derived parsers.
llvm::is_detected< has_parse_method, AttrType > detect_has_parse_method
ParseResult parseSymbolName(StringAttr &result)
Parse an -identifier and store it (without the '@' symbol) in a string attribute.
virtual ParseResult parseLBrace()=0
Parse a { token.
Delimiter
These are the supported delimiters around operand lists and region argument lists,...
@ Paren
Parens surrounding zero or more operands.
@ None
Zero or more operands with no delimiters.
@ OptionalLessGreater
<> brackets supporting zero or more ops, or nothing.
@ Braces
{} brackets surrounding zero or more operands.
@ OptionalBraces
{} brackets surrounding zero or more operands, or nothing.
@ OptionalParen
Parens supporting zero or more operands, or nothing.
@ Square
Square brackets surrounding zero or more operands.
@ LessGreater
<> brackets surrounding zero or more operands.
@ OptionalSquare
Square brackets supporting zero or more ops, or nothing.
virtual OptionalParseResult parseOptionalInteger(APInt &result)=0
Parse an optional integer value from the stream.
AsmParser()=default
virtual ParseResult parseColonTypeList(SmallVectorImpl< Type > &result)=0
Parse a colon followed by a type list, which must have at least one type.
virtual ParseResult parseIntegerSet(IntegerSet &set)=0
Parse an integer set instance into 'set'.
virtual ParseResult parseOptionalKeywordOrString(std::string *result)=0
Parse an optional keyword or string.
virtual ParseResult parseOptionalSymbolName(StringAttr &result)=0
Parse an optional -identifier and store it (without the '@' symbol) in a string attribute.
FailureOr< CyclicParseReset > tryStartCyclicParse(AttrOrTypeT attrOrType)
Attempts to start a cyclic parsing region for attrOrType.
virtual ParseResult parseOptionalRBrace()=0
Parse a } token if present.
virtual ParseResult parsePlus()=0
Parse a '+' token.
ParseResult parseKeyword(StringRef *keyword)
Parse a keyword into 'keyword'.
virtual ParseResult parseCommaSeparatedList(Delimiter delimiter, function_ref< ParseResult()> parseElementFn, StringRef contextMessage=StringRef())=0
Parse a list of comma-separated items with an optional delimiter.
decltype(AttrType::parse(std::declval< AsmParser & >(), std::declval< Type >())) has_parse_method
Trait to check if AttrType provides a parse method.
virtual void popCyclicParsing()=0
Removes the element that was last inserted with a successful call to pushCyclicParsing.
virtual Builder & getBuilder() const =0
Return a builder which provides useful access to MLIRContext, global objects like types and attribute...
virtual ParseResult parseOptionalAttrDict(NamedAttrList &result)=0
Parse a named dictionary into 'result' if it is present.
virtual ParseResult parseOptionalEqual()=0
Parse a = token if present.
virtual ParseResult parseOptionalKeyword(StringRef keyword)=0
Parse the given keyword if present.
virtual OptionalParseResult parseOptionalType(Type &result)=0
Parse an optional type.
MLIRContext * getContext() const
Definition: AsmPrinter.cpp:73
virtual Location getEncodedSourceLoc(SMLoc loc)=0
Re-encode the given source location as an MLIR location and return it.
std::enable_if_t<!detect_type_has_parse_method< TypeT >::value, ParseResult > parseCustomTypeWithFallback(TypeT &result)
SFINAE parsing method for Type that don't implement a parse method.
virtual ParseResult parseRParen()=0
Parse a ) token.
virtual InFlightDiagnostic emitError(SMLoc loc, const Twine &message={})=0
Emit a diagnostic at the specified location and return failure.
virtual ParseResult parseOptionalColon()=0
Parse a : token if present.
virtual ParseResult parseLSquare()=0
Parse a [ token.
virtual ParseResult parseRSquare()=0
Parse a ] token.
virtual ParseResult parseOptionalColonTypeList(SmallVectorImpl< Type > &result)=0
Parse an optional colon followed by a type list, which if present must have at least one type.
ParseResult parseInteger(IntT &result)
Parse an integer value from the stream.
virtual ParseResult parseOptionalArrow()=0
Parse a '->' token if present.
ParseResult parseOptionalSymbolName(StringAttr &result, StringRef attrName, NamedAttrList &attrs)
Parse an optional -identifier and store it (without the '@' symbol) in a string attribute named 'attr...
ParseResult parseAttribute(AttrType &result, Type type, StringRef attrName, NamedAttrList &attrs)
Parse an arbitrary attribute of a given type and populate it in result.
ParseResult parseAttribute(AttrType &result, Type type={})
Parse an attribute of a specific kind and type.
ParseResult parseKeywordOrString(std::string *result)
Parse a keyword or a quoted string.
virtual void codeCompleteExpectedTokens(ArrayRef< StringRef > tokens)=0
Signal the code completion of a set of expected tokens.
virtual ParseResult parseRBrace()=0
Parse a } token.
virtual ParseResult parseAffineMap(AffineMap &map)=0
Parse an affine map instance into 'map'.
ParseResult addTypeToList(Type type, SmallVectorImpl< Type > &result)
Add the specified type to the end of the specified type list and return success.
virtual ParseResult parseOptionalRParen()=0
Parse a ) token if present.
virtual ParseResult parseCustomAttributeWithFallback(Attribute &result, Type type, function_ref< ParseResult(Attribute &result, Type type)> parseAttribute)=0
Parse a custom attribute with the provided callback, unless the next token is #, in which case the ge...
virtual ParseResult parseLess()=0
Parse a '<' token.
virtual ParseResult parseDimensionList(SmallVectorImpl< int64_t > &dimensions, bool allowDynamic=true, bool withTrailingX=true)=0
Parse a dimension list of a tensor or memref type.
ParseResult parseString(std::string *string)
Parse a quoted string token.
virtual ParseResult parseOptionalPlus()=0
Parse a '+' token if present.
virtual ParseResult parseOptionalKeyword(StringRef *keyword, ArrayRef< StringRef > allowedValues)=0
Parse a keyword, if present, and if one of the 'allowedValues', into 'keyword'.
virtual ParseResult parseOptionalGreater()=0
Parse a '>' token if present.
virtual ParseResult parseEqual()=0
Parse a = token.
std::enable_if_t<!detect_has_parse_method< AttrType >::value, ParseResult > parseCustomAttributeWithFallback(AttrType &result, Type type, StringRef attrName, NamedAttrList &attrs)
SFINAE parsing method for Attribute that don't implement a parse method.
virtual ParseResult parseCustomTypeWithFallback(Type &result, function_ref< ParseResult(Type &result)> parseType)=0
Parse a custom type with the provided callback, unless the next token is #, in which case the generic...
virtual ParseResult parseFloat(const llvm::fltSemantics &semantics, APFloat &result)=0
Parse a floating point value into APFloat from the stream.
virtual OptionalParseResult parseOptionalAttribute(ArrayAttr &result, Type type={})=0
Parse an optional array attribute and return it in result.
virtual ParseResult parseStar()=0
Parse a '*' token.
virtual ParseResult parseOptionalAttrDictWithKeyword(NamedAttrList &result)=0
Parse a named dictionary into 'result' if the attributes keyword is present.
virtual ParseResult parseColonType(Type &result)=0
Parse a colon followed by a type.
virtual OptionalParseResult parseOptionalAttribute(Attribute &result, Type type={})=0
Parse an arbitrary optional attribute of a given type and return it in result.
std::enable_if_t< detect_has_parse_method< AttrType >::value, ParseResult > parseCustomAttributeWithFallback(AttrType &result, Type type={})
Parse a custom attribute of a given type unless the next token is #, in which case the generic parser...
ParseResult parseCommaSeparatedList(function_ref< ParseResult()> parseElementFn)
Parse a comma separated list of elements that must have at least one entry in it.
virtual ParseResult parseVerticalBar()=0
Parse a '|' token.
virtual SMLoc getCurrentLocation()=0
Get the location of the next token and store it into the argument.
virtual ParseResult parseOptionalComma()=0
Parse a , token if present.
OptionalParseResult parseOptionalAttribute(AttrType &result, StringRef attrName, NamedAttrList &attrs)
Parse an optional attribute of a specific type and add it to the list with the specified name.
auto getChecked(SMLoc loc, ParamsT &&...params)
Invoke the getChecked method of the given Attribute or Type class, using the provided location to emi...
virtual ParseResult parseColon()=0
Parse a : token.
ParseResult addTypesToList(ArrayRef< Type > types, SmallVectorImpl< Type > &result)
Add the specified types to the end of the specified type list and return success.
std::enable_if_t< detect_type_has_parse_method< TypeT >::value, ParseResult > parseCustomTypeWithFallback(TypeT &result)
Parse a custom Type of a given type unless the next token is #, in which case the generic parser is i...
ParseResult parseAttribute(Attribute &result, StringRef attrName, NamedAttrList &attrs)
Parse an arbitrary attribute and return it in result.
virtual OptionalParseResult parseOptionalAttribute(StringAttr &result, Type type={})=0
Parse an optional string attribute and return it in result.
virtual SMLoc getNameLoc() const =0
Return the location of the original name token.
virtual ParseResult parseOptionalString(std::string *string)=0
Parse a quoted string token if present.
OptionalParseResult parseOptionalInteger(IntT &result)
ParseResult getCurrentLocation(SMLoc *loc)
virtual ParseResult parseOptionalLess()=0
Parse a '<' token if present.
virtual ParseResult parseOptionalStar()=0
Parse a '*' token if present.
OptionalParseResult parseOptionalAttribute(AttrType &result, Type type, StringRef attrName, NamedAttrList &attrs)
Parse an optional attribute of a specific type and add it to the list with the specified name.
virtual OptionalParseResult parseOptionalAttribute(SymbolRefAttr &result, Type type={})=0
Parse an optional symbol ref attribute and return it in result.
virtual ParseResult parseQuestion()=0
Parse a '?' token.
ParseResult parseType(TypeT &result)
Parse a type of a specific type.
virtual ParseResult parseOptionalRSquare()=0
Parse a ] token if present.
virtual ParseResult parseArrow()=0
Parse a '->' token.
ParseResult parseColonType(TypeType &result)
Parse a colon followed by a type of a specific kind, e.g. a FunctionType.
virtual ParseResult parseGreater()=0
Parse a '>' token.
virtual ParseResult parseLParen()=0
Parse a ( token.
virtual ParseResult parseOptionalEllipsis()=0
Parse a ... token if present;.
std::enable_if_t<!detect_has_parse_method< AttrType >::value, ParseResult > parseCustomAttributeWithFallback(AttrType &result, Type type={})
SFINAE parsing method for Attribute that don't implement a parse method.
virtual ParseResult parseType(Type &result)=0
Parse a type.
ParseResult parseAttribute(AttrType &result, StringRef attrName, NamedAttrList &attrs)
Parse an attribute of a specific kind and type.
virtual ParseResult parseEllipsis()=0
Parse a ... token.
auto getChecked(ParamsT &&...params)
A variant of getChecked that uses the result of getNameLoc to emit errors.
virtual ParseResult parseAffineExpr(ArrayRef< std::pair< StringRef, AffineExpr >> symbolSet, AffineExpr &expr)=0
Parse an affine expr instance into 'expr' using the already computed mapping from symbols to affine e...
virtual ParseResult parseComma()=0
Parse a , token.
virtual ParseResult parseOptionalArrowTypeList(SmallVectorImpl< Type > &result)=0
Parse an optional arrow followed by a type list.
virtual ParseResult parseOptionalLParen()=0
Parse a ( token if present.
ParseResult parseKeywordType(const char *keyword, Type &result)
Parse a keyword followed by a type.
virtual ParseResult parseArrowTypeList(SmallVectorImpl< Type > &result)=0
Parse an arrow followed by a type list.
virtual ~AsmParser()
virtual ParseResult parseOptionalVerticalBar()=0
Parse a '|' token if present.
ParseResult parseTypeList(SmallVectorImpl< Type > &result)
Parse a type list.
Definition: AsmPrinter.cpp:77
virtual ParseResult parseBase64Bytes(std::vector< char > *bytes)=0
Parses a Base64 encoded string of bytes.
llvm::is_detected< type_has_parse_method, TypeT > detect_type_has_parse_method
virtual ParseResult parseKeywordOrCompletion(StringRef *keyword)=0
Parse a keyword, or an empty string if the current location signals a code completion.
virtual ParseResult parseFloat(double &result)=0
Parse a floating point value from the stream.
ParseResult parseSymbolName(StringAttr &result, StringRef attrName, NamedAttrList &attrs)
Parse an -identifier and store it (without the '@' symbol) in a string attribute named 'attrName'.
virtual ParseResult parseOptionalKeyword(StringRef *keyword)=0
Parse a keyword, if present, into 'keyword'.
decltype(TypeT::parse(std::declval< AsmParser & >())) type_has_parse_method
Trait to check if TypeT provides a parse method.
ParseResult parseKeyword(StringRef keyword)
Parse a given keyword.
virtual ParseResult parseOptionalLSquare()=0
Parse a [ token if present.
virtual LogicalResult pushCyclicParsing(const void *opaquePointer)=0
Pushes a new attribute or type in the form of a type erased pointer into an internal set.
virtual FailureOr< AsmDialectResourceHandle > parseResourceHandle(Dialect *dialect)=0
Parse a handle to a resource within the assembly format for the given dialect.
virtual ParseResult parseOptionalQuestion()=0
Parse a '?' token if present.
std::enable_if_t< detect_has_parse_method< AttrType >::value, ParseResult > parseCustomAttributeWithFallback(AttrType &result, Type type, StringRef attrName, NamedAttrList &attrs)
Parse a custom attribute of a given type unless the next token is #, in which case the generic parser...
FailureOr< ResourceT > parseResourceHandle()
Parse a handle to a resource within the assembly format.
virtual ParseResult parseAttribute(Attribute &result, Type type={})=0
Parse an arbitrary attribute of a given type and return it in result.
virtual ParseResult parseXInDimensionList()=0
Parse an 'x' token in a dimension list, handling the case where the x is juxtaposed with an element t...
virtual ParseResult parseOptionalLBrace()=0
Parse a { token if present.
virtual ParseResult parseKeyword(StringRef keyword, const Twine &msg)=0
Class used to automatically end a cyclic region on destruction.
CyclicPrintReset & operator=(const CyclicPrintReset &)=delete
CyclicPrintReset(const CyclicPrintReset &)=delete
CyclicPrintReset & operator=(CyclicPrintReset &&rhs)
CyclicPrintReset(CyclicPrintReset &&rhs)
This base class exposes generic asm printer hooks, usable across the various derived printers.
void printStrippedAttrOrType(ArrayRef< AttrOrType > attrOrTypes)
Print the provided array of attributes or types in the context of an operation custom printer/parser:...
FailureOr< CyclicPrintReset > tryStartCyclicPrint(AttrOrTypeT attrOrType)
Attempts to start a cyclic printing region for attrOrType.
virtual void printAttributeWithoutType(Attribute attr)
Print the given attribute without its type.
virtual LogicalResult printAlias(Attribute attr)
Print the alias for the given attribute, return failure if no alias could be printed.
virtual void popCyclicPrinting()
Removes the element that was last inserted with a successful call to pushCyclicPrinting.
AsmPrinter()=default
Initialize the printer with no internal implementation.
void printFunctionalType(InputRangeT &&inputs, ResultRangeT &&results)
Print the two given type ranges in a functional form.
virtual LogicalResult pushCyclicPrinting(const void *opaquePointer)
Pushes a new attribute or type in the form of a type erased pointer into an internal set.
virtual void printType(Type type)
virtual void printKeywordOrString(StringRef keyword)
Print the given string as a keyword, or a quoted and escaped string if it has any special or non-prin...
llvm::is_detected< has_print_method, AttrOrType > detect_has_print_method
virtual void printSymbolName(StringRef symbolRef)
Print the given string as a symbol reference, i.e.
virtual void printString(StringRef string)
Print the given string as a quoted string, escaping any special or non-printable characters in it.
void printOptionalArrowTypeList(TypeRange &&types)
Print an optional arrow followed by a type list.
virtual void printAttribute(Attribute attr)
void printDimensionList(ArrayRef< int64_t > shape)
void printArrowTypeList(TypeRange &&types)
virtual ~AsmPrinter()
virtual raw_ostream & getStream() const
Return the raw output stream used by this printer.
virtual void printResourceHandle(const AsmDialectResourceHandle &resource)
Print a handle to the given dialect resource.
decltype(std::declval< AttrOrType >().print(std::declval< AsmPrinter & >())) has_print_method
Trait to check if AttrType provides a print method.
virtual void printFloat(const APFloat &value)
Print the given floating point value in a stabilized form that can be roundtripped through the IR.
void printStrippedAttrOrType(AttrOrType attrOrType)
Print the provided attribute in the context of an operation custom printer/parser: this will invoke d...
AsmPrinter(Impl &impl)
Initialize the printer with the given internal implementation.
This class is used to build resource entries for use by the printer.
Definition: AsmState.h:239
Attributes are known-constant values of operations.
Definition: Attributes.h:25
This class represents an argument of a Block.
Definition: Value.h:319
Block represents an ordered list of Operations.
Definition: Block.h:31
OpListType::iterator iterator
Definition: Block.h:138
This class is a general helper class for creating context-global objects like types,...
Definition: Builders.h:50
Dialects are groups of MLIR operations, types and attributes, as well as behavior associated with the...
Definition: Dialect.h:38
This class represents a diagnostic that is inflight and set to be reported.
Definition: Diagnostics.h:307
An integer set representing a conjunction of one or more affine equalities and inequalities.
Definition: IntegerSet.h:44
This class defines the main interface for locations in MLIR and acts as a non-nullable wrapper around...
Definition: Location.h:63
MLIRContext is the top-level object for a collection of MLIR operations.
Definition: MLIRContext.h:60
T * getOrLoadDialect()
Get (or create) a dialect for the given derived dialect type.
Definition: MLIRContext.h:97
NamedAttrList is array of NamedAttributes that tracks whether it is sorted and does some basic work t...
void append(StringRef name, Attribute attr)
Add an attribute with the specified name.
virtual void buildResources(Operation *op, const SetVector< AsmDialectResourceHandle > &referencedResources, AsmResourceBuilder &builder) const
Hook for building resources to use during printing.
virtual AliasResult getAlias(Attribute attr, raw_ostream &os) const
Hooks for getting an alias identifier alias for a given symbol, that is not necessarily a part of thi...
OpAsmDialectInterface(Dialect *dialect)
virtual AliasResult getAlias(Type type, raw_ostream &os) const
virtual std::string getResourceKey(const AsmDialectResourceHandle &handle) const
Return a key to use for the given resource.
virtual FailureOr< AsmDialectResourceHandle > declareResource(StringRef key) const
Declare a resource with the given key, returning a handle to use for any references of this resource ...
virtual LogicalResult parseResource(AsmParsedResourceEntry &entry) const
Hook for parsing resource entries.
Definition: AsmPrinter.cpp:130
AliasResult
Holds the result of getAlias hook call.
@ FinalAlias
An alias was provided and it should be used (no other hooks will be checked).
@ NoAlias
The object (type or attribute) is not supported by the hook and an alias was not provided.
@ OverridableAlias
An alias was provided, but it might be overriden by other hook.
The OpAsmParser has methods for interacting with the asm parser: parsing things from it,...
virtual std::pair< StringRef, unsigned > getResultName(unsigned resultNo) const =0
Return the name of the specified result in the specified syntax, as well as the sub-element in the na...
virtual size_t getNumResults() const =0
Return the number of declared SSA results.
virtual OptionalParseResult parseOptionalAssignmentList(SmallVectorImpl< Argument > &lhs, SmallVectorImpl< UnresolvedOperand > &rhs)=0
virtual ParseResult parseRegion(Region &region, ArrayRef< Argument > arguments={}, bool enableNameShadowing=false)=0
Parses a region.
~OpAsmParser() override
virtual ParseResult parseSuccessor(Block *&dest)=0
Parse a single operation successor.
virtual ParseResult parseArgument(Argument &result, bool allowType=false, bool allowAttrs=false)=0
Parse a single argument with the following syntax:
virtual ParseResult parseGenericOperationAfterOpName(OperationState &result, std::optional< ArrayRef< UnresolvedOperand >> parsedOperandType=std::nullopt, std::optional< ArrayRef< Block * >> parsedSuccessors=std::nullopt, std::optional< MutableArrayRef< std::unique_ptr< Region >>> parsedRegions=std::nullopt, std::optional< ArrayRef< NamedAttribute >> parsedAttributes=std::nullopt, std::optional< Attribute > parsedPropertiesAttribute=std::nullopt, std::optional< FunctionType > parsedFnType=std::nullopt)=0
Parse different components, viz., use-info of operand(s), successor(s), region(s),...
ParseResult parseTrailingOperandList(SmallVectorImpl< UnresolvedOperand > &result, Delimiter delimiter=Delimiter::None)
Parse zero or more trailing SSA comma-separated trailing operand references with a specified surround...
ParseResult resolveOperands(Operands &&operands, Type type, SMLoc loc, SmallVectorImpl< Value > &result)
virtual ParseResult parseArgumentList(SmallVectorImpl< Argument > &result, Delimiter delimiter=Delimiter::None, bool allowType=false, bool allowAttrs=false)=0
Parse zero or more arguments with a specified surrounding delimiter.
virtual ParseResult parseAffineMapOfSSAIds(SmallVectorImpl< UnresolvedOperand > &operands, Attribute &map, StringRef attrName, NamedAttrList &attrs, Delimiter delimiter=Delimiter::Square)=0
Parses an affine map attribute where dims and symbols are SSA operands.
virtual OptionalParseResult parseOptionalArgument(Argument &result, bool allowType=false, bool allowAttrs=false)=0
Parse a single argument if present.
virtual ParseResult parseOptionalLocationSpecifier(std::optional< Location > &result)=0
Parse a loc(...) specifier if present, filling in result if so.
ParseResult parseAssignmentList(SmallVectorImpl< Argument > &lhs, SmallVectorImpl< UnresolvedOperand > &rhs)
Parse a list of assignments of the form (x1 = y1, x2 = y2, ...)
virtual ParseResult resolveOperand(const UnresolvedOperand &operand, Type type, SmallVectorImpl< Value > &result)=0
Resolve an operand to an SSA value, emitting an error on failure.
virtual OptionalParseResult parseOptionalOperand(UnresolvedOperand &result, bool allowResultNumber=true)=0
Parse a single operand if present.
virtual ParseResult parseSuccessorAndUseList(Block *&dest, SmallVectorImpl< Value > &operands)=0
Parse a single operation successor and its operand list.
virtual OptionalParseResult parseOptionalRegion(Region &region, ArrayRef< Argument > arguments={}, bool enableNameShadowing=false)=0
Parses a region if present.
virtual FailureOr< OperationName > parseCustomOperationName()=0
Parse the name of an operation, in the custom form.
ParseResult parseOperandList(SmallVectorImpl< UnresolvedOperand > &result, int requiredOperandCount, Delimiter delimiter=Delimiter::None)
Parse a specified number of comma separated operands.
ParseResult resolveOperands(Operands &&operands, Type type, SmallVectorImpl< Value > &result)
Resolve a list of operands to SSA values, emitting an error on failure, or appending the results to t...
virtual Operation * parseGenericOperation(Block *insertBlock, Block::iterator insertPt)=0
Parse an operation in its generic form.
virtual ParseResult parseOperand(UnresolvedOperand &result, bool allowResultNumber=true)=0
Parse a single SSA value operand name along with a result number if allowResultNumber is true.
virtual ParseResult parseAffineExprOfSSAIds(SmallVectorImpl< UnresolvedOperand > &dimOperands, SmallVectorImpl< UnresolvedOperand > &symbOperands, AffineExpr &expr)=0
Parses an affine expression where dims and symbols are SSA operands.
virtual OptionalParseResult parseOptionalSuccessor(Block *&dest)=0
Parse an optional operation successor.
std::enable_if_t<!std::is_convertible< Types, Type >::value, ParseResult > resolveOperands(Operands &&operands, Types &&types, SMLoc loc, SmallVectorImpl< Value > &result)
Resolve a list of operands and a list of operand types to SSA values, emitting an error and returning...
virtual OptionalParseResult parseOptionalRegion(std::unique_ptr< Region > &region, ArrayRef< Argument > arguments={}, bool enableNameShadowing=false)=0
Parses a region if present.
virtual ParseResult parseOperandList(SmallVectorImpl< UnresolvedOperand > &result, Delimiter delimiter=Delimiter::None, bool allowResultNumber=true, int requiredOperandCount=-1)=0
Parse zero or more SSA comma-separated operand references with a specified surrounding delimiter,...
This is a pure-virtual base class that exposes the asmprinter hooks necessary to implement a custom p...
void printOperands(IteratorType it, IteratorType end)
Print a comma separated list of operands.
virtual void shadowRegionArgs(Region &region, ValueRange namesToUse)=0
Renumber the arguments for the specified region to the same names as the SSA values in namesToUse.
virtual void printNewline()=0
Print a newline and indent the printer to the start of the current operation.
virtual void increaseIndent()=0
Increase indentation.
virtual void printSuccessorAndUseList(Block *successor, ValueRange succOperands)=0
Print the successor and its operands.
void printOperands(const ContainerType &container)
Print a comma separated list of operands.
virtual void printOptionalAttrDictWithKeyword(ArrayRef< NamedAttribute > attrs, ArrayRef< StringRef > elidedAttrs={})=0
If the specified operation has attributes, print out an attribute dictionary prefixed with 'attribute...
virtual void printOptionalAttrDict(ArrayRef< NamedAttribute > attrs, ArrayRef< StringRef > elidedAttrs={})=0
If the specified operation has attributes, print out an attribute dictionary with their values.
virtual void printOptionalLocationSpecifier(Location loc)=0
Print a loc(...) specifier if printing debug info is enabled.
virtual void printCustomOrGenericOp(Operation *op)=0
Prints the entire operation with the custom assembly form, if available, or the generic assembly form...
virtual void decreaseIndent()=0
Decrease indentation.
virtual void printOperand(Value value, raw_ostream &os)=0
virtual void printSuccessor(Block *successor)=0
Print the given successor.
virtual void printAffineExprOfSSAIds(AffineExpr expr, ValueRange dimOperands, ValueRange symOperands)=0
Prints an affine expression of SSA ids with SSA id names used instead of dims and symbols.
void printFunctionalType(Operation *op)
Print the complete type of an operation in functional form.
Definition: AsmPrinter.cpp:94
virtual void printAffineMapOfSSAIds(AffineMapAttr mapAttr, ValueRange operands)=0
Prints an affine map of SSA ids, where SSA id names are used in place of dims/symbols.
virtual void printGenericOp(Operation *op, bool printOpName=true)=0
Print the entire operation with the default generic assembly form.
~OpAsmPrinter() override
virtual void printRegion(Region &blocks, bool printEntryBlockArgs=true, bool printBlockTerminators=true, bool printEmptyBlock=false)=0
Prints a region.
virtual void printRegionArgument(BlockArgument arg, ArrayRef< NamedAttribute > argAttrs={}, bool omitType=false)=0
Print a block argument in the usual format of: ssaName : type {attr1=42} loc("here") where location p...
virtual void printOperand(Value value)=0
Print implementations for various things an operation contains.
Operation is the basic unit of execution within MLIR.
Definition: Operation.h:88
This class implements Optional functionality for ParseResult.
Definition: OpDefinition.h:39
ParseResult value() const
Access the internal ParseResult value.
Definition: OpDefinition.h:52
bool has_value() const
Returns true if we contain a valid ParseResult value.
Definition: OpDefinition.h:49
This class contains a list of basic blocks and a link to the parent operation it is attached to.
Definition: Region.h:26
This class provides an efficient unique identifier for a specific C++ type.
Definition: TypeID.h:104
This class provides an abstraction over the various different ranges of value types.
Definition: TypeRange.h:36
Instances of the Type class are uniqued, have an immutable identifier and an optional mutable compone...
Definition: Types.h:74
This class provides an abstraction over the different types of ranges over Values.
Definition: ValueRange.h:381
This class represents an instance of an SSA value in the MLIR system, representing a computable value...
Definition: Value.h:96
The base class used for all derived interface types.
Include the generated interface declarations.
Definition: CallGraph.h:229
QueryRef parse(llvm::StringRef line, const QuerySession &qs)
Definition: Query.cpp:20
Include the generated interface declarations.
ParseResult parseDimensionList(OpAsmParser &parser, DenseI64ArrayAttr &dimensions)
void printDimensionList(OpAsmPrinter &printer, Operation *op, ArrayRef< int64_t > dimensions)
detail::DenseArrayAttrImpl< int64_t > DenseI64ArrayAttr
llvm::hash_code hash_value(const AsmDialectResourceHandle &param)
auto get(MLIRContext *context, Ts &&...params)
Helper method that injects context only if needed, this helps unify some of the attribute constructio...
inline ::llvm::hash_code hash_value(AffineExpr arg)
Make AffineExpr hashable.
Definition: AffineExpr.h:260
raw_ostream & operator<<(raw_ostream &os, const AliasResult &result)
Definition: AliasAnalysis.h:78
static mlir::AsmDialectResourceHandle getTombstoneKey()
static unsigned getHashValue(const mlir::AsmDialectResourceHandle &handle)
static mlir::AsmDialectResourceHandle getEmptyKey()
static bool isEqual(const mlir::AsmDialectResourceHandle &lhs, const mlir::AsmDialectResourceHandle &rhs)
std::optional< Location > sourceLoc
This is the representation of an operand reference.
This represents an operation in an abstracted form, suitable for use with the builder APIs.
This trait is used to determine if a storage user, like Type, is mutable or not.