MLIR  15.0.0git
FunctionImplementation.h
Go to the documentation of this file.
1 //===- FunctionImplementation.h - Function-like Op utilities ----*- 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 file provides utility functions for implementing function-like
10 // operations, in particular, parsing, printing and verification components
11 // common to function-like operations.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef MLIR_IR_FUNCTIONIMPLEMENTATION_H_
16 #define MLIR_IR_FUNCTIONIMPLEMENTATION_H_
17 
20 
21 namespace mlir {
22 
23 namespace function_interface_impl {
24 
25 /// A named class for passing around the variadic flag.
26 class VariadicFlag {
27 public:
28  explicit VariadicFlag(bool variadic) : variadic(variadic) {}
29  bool isVariadic() const { return variadic; }
30 
31 private:
32  /// Underlying storage.
33  bool variadic;
34 };
35 
36 /// Adds argument and result attributes, provided as `argAttrs` and
37 /// `resultAttrs` arguments, to the list of operation attributes in `result`.
38 /// Internally, argument and result attributes are stored as dict attributes
39 /// with special names given by getResultAttrName, getArgumentAttrName.
40 void addArgAndResultAttrs(Builder &builder, OperationState &result,
41  ArrayRef<DictionaryAttr> argAttrs,
42  ArrayRef<DictionaryAttr> resultAttrs);
43 void addArgAndResultAttrs(Builder &builder, OperationState &result,
45  ArrayRef<DictionaryAttr> resultAttrs);
46 
47 /// Callback type for `parseFunctionOp`, the callback should produce the
48 /// type that will be associated with a function-like operation from lists of
49 /// function arguments and results, VariadicFlag indicates whether the function
50 /// should have variadic arguments; in case of error, it may populate the last
51 /// argument with a message.
54 
55 /// Parses a function signature using `parser`. The `allowVariadic` argument
56 /// indicates whether functions with variadic arguments are supported. The
57 /// trailing arguments are populated by this function with names, types,
58 /// attributes and locations of the arguments and those of the results.
60 parseFunctionSignature(OpAsmParser &parser, bool allowVariadic,
62  bool &isVariadic, SmallVectorImpl<Type> &resultTypes,
63  SmallVectorImpl<DictionaryAttr> &resultAttrs);
64 
65 /// Get a function type corresponding to an array of arguments (which have
66 /// types) and a set of result types.
68  ArrayRef<Type> resultTypes);
69 
70 /// Parser implementation for function-like operations. Uses
71 /// `funcTypeBuilder` to construct the custom function type given lists of
72 /// input and output types. If `allowVariadic` is set, the parser will accept
73 /// trailing ellipsis in the function signature and indicate to the builder
74 /// whether the function is variadic. If the builder returns a null type,
75 /// `result` will not contain the `type` attribute. The caller can then add a
76 /// type, report the error or delegate the reporting to the op's verifier.
78  bool allowVariadic,
79  FuncTypeBuilder funcTypeBuilder);
80 
81 /// Printer implementation for function-like operations.
82 void printFunctionOp(OpAsmPrinter &p, FunctionOpInterface op, bool isVariadic);
83 
84 /// Prints the signature of the function-like operation `op`. Assumes `op` has
85 /// is a FunctionOpInterface and has passed verification.
87  ArrayRef<Type> argTypes, bool isVariadic,
88  ArrayRef<Type> resultTypes);
89 
90 /// Prints the list of function prefixed with the "attributes" keyword. The
91 /// attributes with names listed in "elided" as well as those used by the
92 /// function-like operation internally are not printed. Nothing is printed
93 /// if all attributes are elided. Assumes `op` is a FunctionOpInterface and
94 /// has passed verification.
95 void printFunctionAttributes(OpAsmPrinter &p, Operation *op, unsigned numInputs,
96  unsigned numResults,
97  ArrayRef<StringRef> elided = {});
98 
99 } // namespace function_interface_impl
100 
101 } // namespace mlir
102 
103 #endif // MLIR_IR_FUNCTIONIMPLEMENTATION_H_
void printFunctionSignature(OpAsmPrinter &p, Operation *op, ArrayRef< Type > argTypes, bool isVariadic, ArrayRef< Type > resultTypes)
Prints the signature of the function-like operation op.
Include the generated interface declarations.
Operation is a basic unit of execution within MLIR.
Definition: Operation.h:28
void addArgAndResultAttrs(Builder &builder, OperationState &result, ArrayRef< DictionaryAttr > argAttrs, ArrayRef< DictionaryAttr > resultAttrs)
Adds argument and result attributes, provided as argAttrs and resultAttrs arguments, to the list of operation attributes in result.
The OpAsmParser has methods for interacting with the asm parser: parsing things from it...
A named class for passing around the variadic flag.
void printFunctionAttributes(OpAsmPrinter &p, Operation *op, unsigned numInputs, unsigned numResults, ArrayRef< StringRef > elided={})
Prints the list of function prefixed with the "attributes" keyword.
Type getFunctionType(Builder &builder, ArrayRef< OpAsmParser::Argument > argAttrs, ArrayRef< Type > resultTypes)
Get a function type corresponding to an array of arguments (which have types) and a set of result typ...
void printFunctionOp(OpAsmPrinter &p, FunctionOpInterface op, bool isVariadic)
Printer implementation for function-like operations.
This is a pure-virtual base class that exposes the asmprinter hooks necessary to implement a custom p...
This represents an operation in an abstracted form, suitable for use with the builder APIs...
Instances of the Type class are uniqued, have an immutable identifier and an optional mutable compone...
Definition: Types.h:72
ParseResult parseFunctionSignature(OpAsmParser &parser, bool allowVariadic, SmallVectorImpl< OpAsmParser::Argument > &arguments, bool &isVariadic, SmallVectorImpl< Type > &resultTypes, SmallVectorImpl< DictionaryAttr > &resultAttrs)
Parses a function signature using parser.
This class is a general helper class for creating context-global objects like types, attributes, and affine expressions.
Definition: Builders.h:49
ParseResult parseFunctionOp(OpAsmParser &parser, OperationState &result, bool allowVariadic, FuncTypeBuilder funcTypeBuilder)
Parser implementation for function-like operations.
This class represents success/failure for parsing-like operations that find it important to chain tog...