//===- Function.h - MLIR Function Class -------------------------*- 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

//

//===----------------------------------------------------------------------===//

//

// Functions are the basic unit of composition in MLIR.

//

//===----------------------------------------------------------------------===//

#ifndef MLIR_IR_FUNCTION_H

#define MLIR_IR_FUNCTION_H

#include "mlir/IR/Block.h"

#include "mlir/IR/FunctionSupport.h"

#include "mlir/IR/OpDefinition.h"

#include "mlir/IR/SymbolTable.h"

#include "mlir/Interfaces/CallInterfaces.h"

#include "llvm/Support/PointerLikeTypeTraits.h"

namespace mlir {

//===--------------------------------------------------------------------===//

// Function Operation.

//===--------------------------------------------------------------------===//

/// FuncOp represents a function, or an operation containing one region that

/// forms a CFG(Control Flow Graph). The region of a function is not allowed to

/// implicitly capture global values, and all external references must use

/// Function arguments or attributes that establish a symbolic connection(e.g.

/// symbols referenced by name via a string attribute).

class FuncOp

    : public Op<FuncOp, OpTrait::ZeroOperands, OpTrait::ZeroResult,

                OpTrait::OneRegion, OpTrait::IsIsolatedFromAbove,

                OpTrait::FunctionLike, OpTrait::AutomaticAllocationScope,

                OpTrait::AffineScope, CallableOpInterface::Trait,

                SymbolOpInterface::Trait> {

public:

  using Op::Op;

  using Op::print;

  static StringRef getOperationName() { return "func"; }

  static FuncOp create(Location location, StringRef name, FunctionType type,

                       ArrayRef<NamedAttribute> attrs = {});

  static FuncOp create(Location location, StringRef name, FunctionType type,

                       iterator_range<dialect_attr_iterator> attrs);

  static FuncOp create(Location location, StringRef name, FunctionType type,

                       ArrayRef<NamedAttribute> attrs,

                       ArrayRef<MutableDictionaryAttr> argAttrs);

  static void build(OpBuilder &builder, OperationState &result, StringRef name,

                    FunctionType type, ArrayRef<NamedAttribute> attrs);

  static void build(OpBuilder &builder, OperationState &result, StringRef name,

                    FunctionType type, ArrayRef<NamedAttribute> attrs,

                    ArrayRef<MutableDictionaryAttr> argAttrs);

  /// Operation hooks.

  static ParseResult parse(OpAsmParser &parser, OperationState &result);

  void print(OpAsmPrinter &p);

  LogicalResult verify();

  /// Erase a single argument at `argIndex`.

  void eraseArgument(unsigned argIndex) { eraseArguments({argIndex}); }

  /// Erases the arguments listed in `argIndices`.

  /// `argIndices` is allowed to have duplicates and can be in any order.

  void eraseArguments(ArrayRef<unsigned> argIndices);

  /// Create a deep copy of this function and all of its blocks, remapping

  /// any operands that use values outside of the function using the map that is

  /// provided (leaving them alone if no entry is present). If the mapper

  /// contains entries for function arguments, these arguments are not included

  /// in the new function. Replaces references to cloned sub-values with the

  /// corresponding value that is copied, and adds those mappings to the mapper.

  FuncOp clone(BlockAndValueMapping &mapper);

  FuncOp clone();

  /// Clone the internal blocks and attributes from this function into dest. Any

  /// cloned blocks are appended to the back of dest. This function asserts that

  /// the attributes of the current function and dest are compatible.

  void cloneInto(FuncOp dest, BlockAndValueMapping &mapper);

  //===--------------------------------------------------------------------===//

  // CallableOpInterface

  //===--------------------------------------------------------------------===//

  /// Returns the region on the current operation that is callable. This may

  /// return null in the case of an external callable object, e.g. an external

  /// function.

  Region *getCallableRegion() { return isExternal() ? nullptr : &getBody(); }

  /// Returns the results types that the callable region produces when executed.

  ArrayRef<Type> getCallableResults() { return getType().getResults(); }

private:

  // This trait needs access to the hooks defined below.

  friend class OpTrait::FunctionLike<FuncOp>;

  /// Returns the number of arguments. This is a hook for OpTrait::FunctionLike.

  unsigned getNumFuncArguments() { return getType().getInputs().size(); }

  /// Returns the number of results. This is a hook for OpTrait::FunctionLike.

  unsigned getNumFuncResults() { return getType().getResults().size(); }

  /// Hook for OpTrait::FunctionLike, called after verifying that the 'type'

  /// attribute is present and checks if it holds a function type.  Ensures

  /// getType, getNumFuncArguments, and getNumFuncResults can be called safely.

  LogicalResult verifyType() {

    auto type = getTypeAttr().getValue();

    if (!type.isa<FunctionType>())

      return emitOpError("requires '" + getTypeAttrName() +

                         "' attribute of function type");

    return success();

  }

};

} // end namespace mlir

namespace llvm {

// Functions hash just like pointers.

template <> struct DenseMapInfo<mlir::FuncOp> {

  static mlir::FuncOp getEmptyKey() {

    auto pointer = llvm::DenseMapInfo<void *>::getEmptyKey();

    return mlir::FuncOp::getFromOpaquePointer(pointer);

  }

  static mlir::FuncOp getTombstoneKey() {

    auto pointer = llvm::DenseMapInfo<void *>::getTombstoneKey();

    return mlir::FuncOp::getFromOpaquePointer(pointer);

  }

  static unsigned getHashValue(mlir::FuncOp val) {

    return hash_value(val.getAsOpaquePointer());

  }

  static bool isEqual(mlir::FuncOp LHS, mlir::FuncOp RHS) { return LHS == RHS; }

};

/// Allow stealing the low bits of FuncOp.

template <> struct PointerLikeTypeTraits<mlir::FuncOp> {

public:

  static inline void *getAsVoidPointer(mlir::FuncOp I) {

    return const_cast<void *>(I.getAsOpaquePointer());

  }

  static inline mlir::FuncOp getFromVoidPointer(void *P) {

    return mlir::FuncOp::getFromOpaquePointer(P);

  }

  static constexpr int NumLowBitsAvailable = 3;

};

} // namespace llvm

#endif // MLIR_IR_FUNCTION_H