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
18#include "mlir/IR/OpImplementation.h"
19#include "mlir/Interfaces/FunctionInterfaces.h"
20
21namespace mlir {
22
23namespace function_interface_impl {
24
25/// A named class for passing around the variadic flag.
26class VariadicFlag {
27public:
28 explicit VariadicFlag(bool variadic) : variadic(variadic) {}
29 bool isVariadic() const { return variadic; }
30
31private:
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.
40void addArgAndResultAttrs(Builder &builder, OperationState &result,
41 ArrayRef<DictionaryAttr> argAttrs,
42 ArrayRef<DictionaryAttr> resultAttrs,
43 StringAttr argAttrsName, StringAttr resAttrsName);
44void addArgAndResultAttrs(Builder &builder, OperationState &result,
45 ArrayRef<OpAsmParser::Argument> args,
46 ArrayRef<DictionaryAttr> resultAttrs,
47 StringAttr argAttrsName, StringAttr resAttrsName);
48
49/// Callback type for `parseFunctionOp`, the callback should produce the
50/// type that will be associated with a function-like operation from lists of
51/// function arguments and results, VariadicFlag indicates whether the function
52/// should have variadic arguments; in case of error, it may populate the last
53/// argument with a message.
54using FuncTypeBuilder = function_ref<Type(
55 Builder &, ArrayRef<Type>, ArrayRef<Type>, VariadicFlag, std::string &)>;
56
57/// Parses a function signature using `parser`. The `allowVariadic` argument
58/// indicates whether functions with variadic arguments are supported. The
59/// trailing arguments are populated by this function with names, types,
60/// attributes and locations of the arguments and those of the results.
61ParseResult
62parseFunctionSignature(OpAsmParser &parser, bool allowVariadic,
63 SmallVectorImpl<OpAsmParser::Argument> &arguments,
64 bool &isVariadic, SmallVectorImpl<Type> &resultTypes,
65 SmallVectorImpl<DictionaryAttr> &resultAttrs);
66
67/// Parser implementation for function-like operations. Uses
68/// `funcTypeBuilder` to construct the custom function type given lists of
69/// input and output types. The parser sets the `typeAttrName` attribute to the
70/// resulting function type. If `allowVariadic` is set, the parser will accept
71/// trailing ellipsis in the function signature and indicate to the builder
72/// whether the function is variadic. If the builder returns a null type,
73/// `result` will not contain the `type` attribute. The caller can then add a
74/// type, report the error or delegate the reporting to the op's verifier.
75ParseResult parseFunctionOp(OpAsmParser &parser, OperationState &result,
76 bool allowVariadic, StringAttr typeAttrName,
77 FuncTypeBuilder funcTypeBuilder,
78 StringAttr argAttrsName, StringAttr resAttrsName);
79
80/// Printer implementation for function-like operations.
81void printFunctionOp(OpAsmPrinter &p, FunctionOpInterface op, bool isVariadic,
82 StringRef typeAttrName, StringAttr argAttrsName,
83 StringAttr resAttrsName);
84
85/// Prints the signature of the function-like operation `op`. Assumes `op` has
86/// is a FunctionOpInterface and has passed verification.
87void printFunctionSignature(OpAsmPrinter &p, FunctionOpInterface op,
88 ArrayRef<Type> argTypes, bool isVariadic,
89 ArrayRef<Type> resultTypes);
90
91/// Prints the list of function prefixed with the "attributes" keyword. The
92/// attributes with names listed in "elided" as well as those used by the
93/// function-like operation internally are not printed. Nothing is printed
94/// if all attributes are elided. Assumes `op` is a FunctionOpInterface and
95/// has passed verification.
96void printFunctionAttributes(OpAsmPrinter &p, Operation *op,
97 ArrayRef<StringRef> elided = {});
98
99} // namespace function_interface_impl
100
101} // namespace mlir
102
103#endif // MLIR_IR_FUNCTIONIMPLEMENTATION_H_
104

source code of mlir/include/mlir/Interfaces/FunctionImplementation.h