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/FunctionSupport.h"
19 #include "mlir/IR/OpImplementation.h"
20 
21 namespace mlir {
22 
23 namespace function_like_impl {
24 
25 /// A named class for passing around the variadic flag.
26 class VariadicFlag {
27 public:
VariadicFlag(bool variadic)28   explicit VariadicFlag(bool variadic) : variadic(variadic) {}
isVariadic()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,
44                           ArrayRef<NamedAttrList> argAttrs,
45                           ArrayRef<NamedAttrList> resultAttrs);
46 
47 /// Callback type for `parseFunctionLikeOp`, 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.
52 using FuncTypeBuilder = function_ref<Type(
53     Builder &, ArrayRef<Type>, ArrayRef<Type>, VariadicFlag, std::string &)>;
54 
55 /// Parses function arguments 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 and
58 /// attributes of the arguments.
59 ParseResult parseFunctionArgumentList(
60     OpAsmParser &parser, bool allowAttributes, bool allowVariadic,
61     SmallVectorImpl<OpAsmParser::OperandType> &argNames,
62     SmallVectorImpl<Type> &argTypes, SmallVectorImpl<NamedAttrList> &argAttrs,
63     bool &isVariadic);
64 
65 /// Parses a function signature using `parser`. The `allowVariadic` argument
66 /// indicates whether functions with variadic arguments are supported. The
67 /// trailing arguments are populated by this function with names, types and
68 /// attributes of the arguments and those of the results.
69 ParseResult
70 parseFunctionSignature(OpAsmParser &parser, bool allowVariadic,
71                        SmallVectorImpl<OpAsmParser::OperandType> &argNames,
72                        SmallVectorImpl<Type> &argTypes,
73                        SmallVectorImpl<NamedAttrList> &argAttrs,
74                        bool &isVariadic, SmallVectorImpl<Type> &resultTypes,
75                        SmallVectorImpl<NamedAttrList> &resultAttrs);
76 
77 /// Parser implementation for function-like operations.  Uses
78 /// `funcTypeBuilder` to construct the custom function type given lists of
79 /// input and output types.  If `allowVariadic` is set, the parser will accept
80 /// trailing ellipsis in the function signature and indicate to the builder
81 /// whether the function is variadic.  If the builder returns a null type,
82 /// `result` will not contain the `type` attribute.  The caller can then add a
83 /// type, report the error or delegate the reporting to the op's verifier.
84 ParseResult parseFunctionLikeOp(OpAsmParser &parser, OperationState &result,
85                                 bool allowVariadic,
86                                 FuncTypeBuilder funcTypeBuilder);
87 
88 /// Printer implementation for function-like operations.  Accepts lists of
89 /// argument and result types to use while printing.
90 void printFunctionLikeOp(OpAsmPrinter &p, Operation *op,
91                          ArrayRef<Type> argTypes, bool isVariadic,
92                          ArrayRef<Type> resultTypes);
93 
94 /// Prints the signature of the function-like operation `op`.  Assumes `op` has
95 /// the FunctionLike trait and passed the verification.
96 void printFunctionSignature(OpAsmPrinter &p, Operation *op,
97                             ArrayRef<Type> argTypes, bool isVariadic,
98                             ArrayRef<Type> resultTypes);
99 
100 /// Prints the list of function prefixed with the "attributes" keyword. The
101 /// attributes with names listed in "elided" as well as those used by the
102 /// function-like operation internally are not printed. Nothing is printed
103 /// if all attributes are elided. Assumes `op` has the `FunctionLike` trait and
104 /// passed the verification.
105 void printFunctionAttributes(OpAsmPrinter &p, Operation *op, unsigned numInputs,
106                              unsigned numResults,
107                              ArrayRef<StringRef> elided = {});
108 
109 } // namespace function_like_impl
110 
111 } // namespace mlir
112 
113 #endif // MLIR_IR_FUNCTIONIMPLEMENTATION_H_
114