InliningUtils.h

Go to the documentation of this file.

//===- InliningUtils.h - Inliner 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 header file defines interfaces for various inlining utility methods.
//
//===----------------------------------------------------------------------===//

#ifndef MLIR_TRANSFORMS_INLINING_UTILS_H
#define MLIR_TRANSFORMS_INLINING_UTILS_H

#include "mlir/IR/DialectInterface.h"
#include "mlir/IR/Location.h"
#include "mlir/IR/Region.h"

namespace mlir {

class Block;
class BlockAndValueMapping;
class CallableOpInterface;
class CallOpInterface;
class FuncOp;
class OpBuilder;
class Operation;
class Region;
class Value;

//===----------------------------------------------------------------------===//
// InlinerInterface
//===----------------------------------------------------------------------===//

class DialectInlinerInterface
    : public DialectInterface::Base<DialectInlinerInterface> {
public:
  DialectInlinerInterface(Dialect *dialect) : Base(dialect) {}

  //===--------------------------------------------------------------------===//
  // Analysis Hooks
  //===--------------------------------------------------------------------===//

  virtual bool isLegalToInline(Region *dest, Region *src,
                               BlockAndValueMapping &valueMapping) const {
    return false;
  }

  virtual bool isLegalToInline(Operation *op, Region *dest,
                               BlockAndValueMapping &valueMapping) const {
    return false;
  }

  virtual bool shouldAnalyzeRecursively(Operation *op) const { return true; }

  //===--------------------------------------------------------------------===//
  // Transformation Hooks
  //===--------------------------------------------------------------------===//

  virtual void handleTerminator(Operation *op, Block *newDest) const {
    llvm_unreachable("must implement handleTerminator in the case of multiple "
                     "inlined blocks");
  }

  virtual void handleTerminator(Operation *op,
                                ArrayRef<Value> valuesToReplace) const {
    llvm_unreachable(
        "must implement handleTerminator in the case of one inlined block");
  }

  virtual Operation *materializeCallConversion(OpBuilder &builder, Value input,
                                               Type resultType,
                                               Location conversionLoc) const {
    return nullptr;
  }
};

class InlinerInterface
    : public DialectInterfaceCollection<DialectInlinerInterface> {
public:
  using Base::Base;

  virtual void
  processInlinedBlocks(iterator_range<Region::iterator> inlinedBlocks) {}


  //===--------------------------------------------------------------------===//
  // Analysis Hooks
  //===--------------------------------------------------------------------===//

  virtual bool isLegalToInline(Region *dest, Region *src,
                               BlockAndValueMapping &valueMapping) const;
  virtual bool isLegalToInline(Operation *op, Region *dest,
                               BlockAndValueMapping &valueMapping) const;
  virtual bool shouldAnalyzeRecursively(Operation *op) const;

  //===--------------------------------------------------------------------===//
  // Transformation Hooks
  //===--------------------------------------------------------------------===//

  virtual void handleTerminator(Operation *op, Block *newDest) const;
  virtual void handleTerminator(Operation *op,
                                ArrayRef<Value> valuesToRepl) const;
};

//===----------------------------------------------------------------------===//
// Inline Methods.
//===----------------------------------------------------------------------===//

LogicalResult inlineRegion(InlinerInterface &interface, Region *src,
                           Operation *inlinePoint, BlockAndValueMapping &mapper,
                           ArrayRef<Value> resultsToReplace,
                           Optional<Location> inlineLoc = llvm::None,
                           bool shouldCloneInlinedRegion = true);

LogicalResult inlineRegion(InlinerInterface &interface, Region *src,
                           Operation *inlinePoint,
                           ArrayRef<Value> inlinedOperands,
                           ArrayRef<Value> resultsToReplace,
                           Optional<Location> inlineLoc = llvm::None,
                           bool shouldCloneInlinedRegion = true);

LogicalResult inlineCall(InlinerInterface &interface, CallOpInterface call,
                         CallableOpInterface callable, Region *src,
                         bool shouldCloneInlinedRegion = true);

} // end namespace mlir

#endif // MLIR_TRANSFORMS_INLINING_UTILS_H