| //===- FunctionImplementation.h - Function-like Op utilities ----*- C++ -*-===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // This file provides utility functions for implementing function-like |
| // operations, in particular, parsing, printing and verification components |
| // common to function-like operations. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef MLIR_IR_FUNCTIONIMPLEMENTATION_H_ |
| #define MLIR_IR_FUNCTIONIMPLEMENTATION_H_ |
| |
| #include "mlir/IR/FunctionSupport.h" |
| #include "mlir/IR/OpImplementation.h" |
| |
| namespace mlir { |
| |
| namespace impl { |
| |
| /// A named class for passing around the variadic flag. |
| class VariadicFlag { |
| public: |
| explicit VariadicFlag(bool variadic) : variadic(variadic) {} |
| bool isVariadic() const { return variadic; } |
| |
| private: |
| /// Underlying storage. |
| bool variadic; |
| }; |
| |
| /// Adds argument and result attributes, provided as `argAttrs` and |
| /// `resultAttrs` arguments, to the list of operation attributes in `result`. |
| /// Internally, argument and result attributes are stored as dict attributes |
| /// with special names given by getResultAttrName, getArgumentAttrName. |
| void addArgAndResultAttrs(Builder &builder, OperationState &result, |
| ArrayRef<NamedAttrList> argAttrs, |
| ArrayRef<NamedAttrList> resultAttrs); |
| |
| /// Callback type for `parseFunctionLikeOp`, the callback should produce the |
| /// type that will be associated with a function-like operation from lists of |
| /// function arguments and results, VariadicFlag indicates whether the function |
| /// should have variadic arguments; in case of error, it may populate the last |
| /// argument with a message. |
| using FuncTypeBuilder = function_ref<Type( |
| Builder &, ArrayRef<Type>, ArrayRef<Type>, VariadicFlag, std::string &)>; |
| |
| /// Parses a function signature using `parser`. The `allowVariadic` argument |
| /// indicates whether functions with variadic arguments are supported. The |
| /// trailing arguments are populated by this function with names, types and |
| /// attributes of the arguments and those of the results. |
| ParseResult |
| parseFunctionSignature(OpAsmParser &parser, bool allowVariadic, |
| SmallVectorImpl<OpAsmParser::OperandType> &argNames, |
| SmallVectorImpl<Type> &argTypes, |
| SmallVectorImpl<NamedAttrList> &argAttrs, |
| bool &isVariadic, SmallVectorImpl<Type> &resultTypes, |
| SmallVectorImpl<NamedAttrList> &resultAttrs); |
| |
| /// Parser implementation for function-like operations. Uses |
| /// `funcTypeBuilder` to construct the custom function type given lists of |
| /// input and output types. If `allowVariadic` is set, the parser will accept |
| /// trailing ellipsis in the function signature and indicate to the builder |
| /// whether the function is variadic. If the builder returns a null type, |
| /// `result` will not contain the `type` attribute. The caller can then add a |
| /// type, report the error or delegate the reporting to the op's verifier. |
| ParseResult parseFunctionLikeOp(OpAsmParser &parser, OperationState &result, |
| bool allowVariadic, |
| FuncTypeBuilder funcTypeBuilder); |
| |
| /// Printer implementation for function-like operations. Accepts lists of |
| /// argument and result types to use while printing. |
| void printFunctionLikeOp(OpAsmPrinter &p, Operation *op, |
| ArrayRef<Type> argTypes, bool isVariadic, |
| ArrayRef<Type> resultTypes); |
| |
| /// Prints the signature of the function-like operation `op`. Assumes `op` has |
| /// the FunctionLike trait and passed the verification. |
| void printFunctionSignature(OpAsmPrinter &p, Operation *op, |
| ArrayRef<Type> argTypes, bool isVariadic, |
| ArrayRef<Type> resultTypes); |
| |
| /// Prints the list of function prefixed with the "attributes" keyword. The |
| /// attributes with names listed in "elided" as well as those used by the |
| /// function-like operation internally are not printed. Nothing is printed |
| /// if all attributes are elided. Assumes `op` has the `FunctionLike` trait and |
| /// passed the verification. |
| void printFunctionAttributes(OpAsmPrinter &p, Operation *op, unsigned numInputs, |
| unsigned numResults, |
| ArrayRef<StringRef> elided = {}); |
| |
| } // namespace impl |
| |
| } // namespace mlir |
| |
| #endif // MLIR_IR_FUNCTIONIMPLEMENTATION_H_ |