FunctionImplementation.h

Go to the documentation of this file.

//===- FunctionImplementation.h - Function-like Op utilities ----*- C++ -*-===//
//
// Part of the MLIR 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 {

class VariadicFlag {
public:
  explicit VariadicFlag(bool variadic) : variadic(variadic) {}
  bool isVariadic() const { return variadic; }

private:
  bool variadic;
};

void addArgAndResultAttrs(Builder &builder, OperationState &result,
                          ArrayRef<SmallVector<NamedAttribute, 2>> argAttrs,
                          ArrayRef<SmallVector<NamedAttribute, 2>> resultAttrs);

using FuncTypeBuilder = function_ref<Type(
    Builder &, ArrayRef<Type>, ArrayRef<Type>, VariadicFlag, std::string &)>;

ParseResult parseFunctionSignature(
    OpAsmParser &parser, bool allowVariadic,
    SmallVectorImpl<OpAsmParser::OperandType> &argNames,
    SmallVectorImpl<Type> &argTypes,
    SmallVectorImpl<SmallVector<NamedAttribute, 2>> &argAttrs, bool &isVariadic,
    SmallVectorImpl<Type> &resultTypes,
    SmallVectorImpl<SmallVector<NamedAttribute, 2>> &resultAttrs);

ParseResult parseFunctionLikeOp(OpAsmParser &parser, OperationState &result,
                                bool allowVariadic,
                                FuncTypeBuilder funcTypeBuilder);

void printFunctionLikeOp(OpAsmPrinter &p, Operation *op,
                         ArrayRef<Type> argTypes, bool isVariadic,
                         ArrayRef<Type> resultTypes);

void printFunctionSignature(OpAsmPrinter &p, Operation *op,
                            ArrayRef<Type> argTypes, bool isVariadic,
                            ArrayRef<Type> resultTypes);

void printFunctionAttributes(OpAsmPrinter &p, Operation *op, unsigned numInputs,
                             unsigned numResults,
                             ArrayRef<StringRef> elided = {});

} // namespace impl

} // namespace mlir

#endif // MLIR_IR_FUNCTIONIMPLEMENTATION_H_