Function.h

Go to the documentation of this file.

//===- Function.h - MLIR Function Class -------------------------*- 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
//
//===----------------------------------------------------------------------===//
//
// Functions are the basic unit of composition in MLIR.
//
//===----------------------------------------------------------------------===//

#ifndef MLIR_IR_FUNCTION_H
#define MLIR_IR_FUNCTION_H

#include "mlir/Analysis/CallInterfaces.h"
#include "mlir/IR/Block.h"
#include "mlir/IR/FunctionSupport.h"
#include "mlir/IR/OpDefinition.h"
#include "mlir/IR/SymbolTable.h"

namespace mlir {
//===--------------------------------------------------------------------===//
// Function Operation.
//===--------------------------------------------------------------------===//

class FuncOp : public Op<FuncOp, OpTrait::ZeroOperands, OpTrait::ZeroResult,
                         OpTrait::IsIsolatedFromAbove, OpTrait::Symbol,
                         OpTrait::FunctionLike, CallableOpInterface::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<NamedAttributeList> argAttrs);

  static void build(Builder *builder, OperationState &result, StringRef name,
                    FunctionType type, ArrayRef<NamedAttribute> attrs);
  static void build(Builder *builder, OperationState &result, StringRef name,
                    FunctionType type, ArrayRef<NamedAttribute> attrs,
                    ArrayRef<NamedAttributeList> argAttrs);

  static ParseResult parse(OpAsmParser &parser, OperationState &result);
  void print(OpAsmPrinter &p);
  LogicalResult verify();

  void eraseArgument(unsigned argIndex) { eraseArguments({argIndex}); }
  void eraseArguments(ArrayRef<unsigned> argIndices);

  FunctionType getType() {
    return getAttrOfType<TypeAttr>(getTypeAttrName())
        .getValue()
        .cast<FunctionType>();
  }

  void setType(FunctionType newType) {
    SmallVector<char, 16> nameBuf;
    auto oldType = getType();
    for (int i = newType.getNumInputs(), e = oldType.getNumInputs(); i < e;
         i++) {
      removeAttr(getArgAttrName(i, nameBuf));
    }
    for (int i = newType.getNumResults(), e = oldType.getNumResults(); i < e;
         i++) {
      removeAttr(getResultAttrName(i, nameBuf));
    }
    setAttr(getTypeAttrName(), TypeAttr::get(newType));
  }

  FuncOp clone(BlockAndValueMapping &mapper);
  FuncOp clone();

  void cloneInto(FuncOp dest, BlockAndValueMapping &mapper);

  //===--------------------------------------------------------------------===//
  // Body Handling
  //===--------------------------------------------------------------------===//

  Block *addEntryBlock();

  Block *addBlock();

  //===--------------------------------------------------------------------===//
  // CallableOpInterface
  //===--------------------------------------------------------------------===//

  Region *getCallableRegion(CallInterfaceCallable callable) {
    assert(callable.get<SymbolRefAttr>().getLeafReference() == getName());
    return isExternal() ? nullptr : &getBody();
  }

  void getCallableRegions(SmallVectorImpl<Region *> &callables) {
    if (!isExternal())
      callables.push_back(&getBody());
  }

  ArrayRef<Type> getCallableResults(Region *region) {
    assert(!isExternal() && region == &getBody() && "invalid callable");
    return getType().getResults();
  }

private:
  // This trait needs access to the hooks defined below.
  friend class OpTrait::FunctionLike<FuncOp>;

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

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

  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; }
};

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);
  }
  enum { NumLowBitsAvailable = 3 };
};

} // namespace llvm

#endif // MLIR_IR_FUNCTION_H