Operation.h

Go to the documentation of this file.

//===- Operation.h - MLIR Operation 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
//
//===----------------------------------------------------------------------===//
//
// This file defines the Operation class.
//
//===----------------------------------------------------------------------===//

#ifndef MLIR_IR_OPERATION_H
#define MLIR_IR_OPERATION_H

#include "mlir/IR/Block.h"
#include "mlir/IR/Diagnostics.h"
#include "mlir/IR/OperationSupport.h"
#include "mlir/IR/Region.h"
#include "llvm/ADT/Twine.h"

namespace mlir {
class Operation final
    : public IRMultiObjectWithUseList<OpOperand>,
      public llvm::ilist_node_with_parent<Operation, Block>,
      private llvm::TrailingObjects<Operation, detail::TrailingOpResult,
                                    BlockOperand, Region,
                                    detail::OperandStorage> {
public:
  static Operation *create(Location location, OperationName name,
                           ArrayRef<Type> resultTypes, ArrayRef<Value> operands,
                           ArrayRef<NamedAttribute> attributes,
                           ArrayRef<Block *> successors, unsigned numRegions,
                           bool resizableOperandList);

  static Operation *create(Location location, OperationName name,
                           ArrayRef<Type> resultTypes, ArrayRef<Value> operands,
                           NamedAttributeList attributes,
                           ArrayRef<Block *> successors, unsigned numRegions,
                           bool resizableOperandList);

  static Operation *create(const OperationState &state);

  static Operation *create(Location location, OperationName name,
                           ArrayRef<Type> resultTypes, ArrayRef<Value> operands,
                           NamedAttributeList attributes,
                           ArrayRef<Block *> successors = {},
                           RegionRange regions = {},
                           bool resizableOperandList = false);

  OperationName getName() { return name; }

  const AbstractOperation *getAbstractOperation() {
    return getName().getAbstractOperation();
  }

  bool isRegistered() { return getAbstractOperation(); }

  void erase();

  Operation *clone(BlockAndValueMapping &mapper);
  Operation *clone();

  Operation *cloneWithoutRegions(BlockAndValueMapping &mapper);

  Operation *cloneWithoutRegions();

  Block *getBlock() { return block; }

  MLIRContext *getContext();

  Dialect *getDialect();

  Location getLoc() { return location; }

  void setLoc(Location loc) { location = loc; }

  Region *getParentRegion();

  Operation *getParentOp();

  template <typename OpTy> OpTy getParentOfType() {
    auto *op = this;
    while ((op = op->getParentOp()))
      if (auto parentOp = dyn_cast<OpTy>(op))
        return parentOp;
    return OpTy();
  }

  bool isProperAncestor(Operation *other);

  bool isAncestor(Operation *other) {
    return this == other || isProperAncestor(other);
  }

  void replaceUsesOfWith(Value from, Value to);

  template <typename ValuesT,
            typename = decltype(std::declval<ValuesT>().begin())>
  void replaceAllUsesWith(ValuesT &&values) {
    assert(std::distance(values.begin(), values.end()) == getNumResults() &&
           "expected 'values' to correspond 1-1 with the number of results");

    auto valueIt = values.begin();
    for (unsigned i = 0, e = getNumResults(); i != e; ++i)
      getResult(i)->replaceAllUsesWith(*(valueIt++));
  }

  void replaceAllUsesWith(Operation *op) {
    assert(getNumResults() == op->getNumResults());
    for (unsigned i = 0, e = getNumResults(); i != e; ++i)
      getResult(i)->replaceAllUsesWith(op->getResult(i));
  }

  void destroy();

  void dropAllReferences();

  void dropAllDefinedValueUses();

  void moveBefore(Operation *existingOp);

  void moveBefore(Block *block, llvm::iplist<Operation>::iterator iterator);

  bool isBeforeInBlock(Operation *other);

  void print(raw_ostream &os, OpPrintingFlags flags = llvm::None);
  void dump();

  //===--------------------------------------------------------------------===//
  // Operands
  //===--------------------------------------------------------------------===//

  bool hasResizableOperandsList() { return getOperandStorage().isResizable(); }

  void setOperands(ValueRange operands);

  unsigned getNumOperands() { return getOperandStorage().size(); }

  Value getOperand(unsigned idx) { return getOpOperand(idx).get(); }
  void setOperand(unsigned idx, Value value) {
    return getOpOperand(idx).set(value);
  }

  // Support operand iteration.
  using operand_range = OperandRange;
  using operand_iterator = operand_range::iterator;

  operand_iterator operand_begin() { return getOperands().begin(); }
  operand_iterator operand_end() { return getOperands().end(); }

  operand_range getOperands() { return operand_range(this); }

  void eraseOperand(unsigned idx) { getOperandStorage().eraseOperand(idx); }

  MutableArrayRef<OpOperand> getOpOperands() {
    return getOperandStorage().getOperands();
  }

  OpOperand &getOpOperand(unsigned idx) { return getOpOperands()[idx]; }

  // Support operand type iteration.
  using operand_type_iterator = operand_range::type_iterator;
  using operand_type_range = iterator_range<operand_type_iterator>;
  operand_type_iterator operand_type_begin() { return operand_begin(); }
  operand_type_iterator operand_type_end() { return operand_end(); }
  operand_type_range getOperandTypes() { return getOperands().getTypes(); }

  //===--------------------------------------------------------------------===//
  // Results
  //===--------------------------------------------------------------------===//

  unsigned getNumResults();

  OpResult getResult(unsigned idx) { return OpResult(this, idx); }

  using result_range = ResultRange;
  using result_iterator = result_range::iterator;

  result_iterator result_begin() { return getResults().begin(); }
  result_iterator result_end() { return getResults().end(); }
  result_range getResults() { return result_range(this); }

  result_range getOpResults() { return getResults(); }
  OpResult getOpResult(unsigned idx) { return getResult(idx); }

  using result_type_iterator = result_range::type_iterator;
  using result_type_range = iterator_range<result_type_iterator>;
  result_type_iterator result_type_begin() { return result_begin(); }
  result_type_iterator result_type_end() { return result_end(); }
  result_type_range getResultTypes() { return getResults().getTypes(); }

  //===--------------------------------------------------------------------===//
  // Attributes
  //===--------------------------------------------------------------------===//

  // Operations may optionally carry a list of attributes that associate
  // constants to names.  Attributes may be dynamically added and removed over
  // the lifetime of an operation.

  ArrayRef<NamedAttribute> getAttrs() { return attrs.getAttrs(); }

  NamedAttributeList &getAttrList() { return attrs; }

  void setAttrs(NamedAttributeList newAttrs) { attrs = newAttrs; }

  Attribute getAttr(Identifier name) { return attrs.get(name); }
  Attribute getAttr(StringRef name) { return attrs.get(name); }

  template <typename AttrClass> AttrClass getAttrOfType(Identifier name) {
    return getAttr(name).dyn_cast_or_null<AttrClass>();
  }

  template <typename AttrClass> AttrClass getAttrOfType(StringRef name) {
    return getAttr(name).dyn_cast_or_null<AttrClass>();
  }

  void setAttr(Identifier name, Attribute value) { attrs.set(name, value); }
  void setAttr(StringRef name, Attribute value) {
    setAttr(Identifier::get(name, getContext()), value);
  }

  NamedAttributeList::RemoveResult removeAttr(Identifier name) {
    return attrs.remove(name);
  }

  class dialect_attr_iterator
      : public llvm::filter_iterator<ArrayRef<NamedAttribute>::iterator,
                                     bool (*)(NamedAttribute)> {
    static bool filter(NamedAttribute attr) {
      // Dialect attributes are prefixed by the dialect name, like operations.
      return attr.first.strref().count('.');
    }

    explicit dialect_attr_iterator(ArrayRef<NamedAttribute>::iterator it,
                                   ArrayRef<NamedAttribute>::iterator end)
        : llvm::filter_iterator<ArrayRef<NamedAttribute>::iterator,
                                bool (*)(NamedAttribute)>(it, end, &filter) {}

    // Allow access to the constructor.
    friend Operation;
  };
  using dialect_attr_range = iterator_range<dialect_attr_iterator>;

  dialect_attr_range getDialectAttrs() {
    auto attrs = getAttrs();
    return {dialect_attr_iterator(attrs.begin(), attrs.end()),
            dialect_attr_iterator(attrs.end(), attrs.end())};
  }
  dialect_attr_iterator dialect_attr_begin() {
    auto attrs = getAttrs();
    return dialect_attr_iterator(attrs.begin(), attrs.end());
  }
  dialect_attr_iterator dialect_attr_end() {
    auto attrs = getAttrs();
    return dialect_attr_iterator(attrs.end(), attrs.end());
  }

  template <typename DialectAttrT>
  void setDialectAttrs(DialectAttrT &&dialectAttrs) {
    SmallVector<NamedAttribute, 16> attrs;
    attrs.assign(std::begin(dialectAttrs), std::end(dialectAttrs));
    for (auto attr : getAttrs())
      if (!attr.first.strref().count('.'))
        attrs.push_back(attr);
    setAttrs(llvm::makeArrayRef(attrs));
  }

  //===--------------------------------------------------------------------===//
  // Blocks
  //===--------------------------------------------------------------------===//

  unsigned getNumRegions() { return numRegions; }

  MutableArrayRef<Region> getRegions() {
    auto *regions = getTrailingObjects<Region>();
    return {regions, numRegions};
  }

  Region &getRegion(unsigned index) {
    assert(index < numRegions && "invalid region index");
    return getRegions()[index];
  }

  //===--------------------------------------------------------------------===//
  // Terminators
  //===--------------------------------------------------------------------===//

  MutableArrayRef<BlockOperand> getBlockOperands() {
    return {getTrailingObjects<BlockOperand>(), numSuccs};
  }

  // Successor iteration.
  using succ_iterator = SuccessorRange::iterator;
  succ_iterator successor_begin() { return getSuccessors().begin(); }
  succ_iterator successor_end() { return getSuccessors().end(); }
  SuccessorRange getSuccessors() { return SuccessorRange(this); }

  operand_range getNonSuccessorOperands();

  operand_range getSuccessorOperands(unsigned index);

  Value getSuccessorOperand(unsigned succIndex, unsigned opIndex) {
    assert(!isKnownNonTerminator() && "only terminators may have successors");
    assert(opIndex < getNumSuccessorOperands(succIndex));
    return getOperand(getSuccessorOperandIndex(succIndex) + opIndex);
  }

  bool hasSuccessors() { return numSuccs != 0; }
  unsigned getNumSuccessors() { return numSuccs; }
  unsigned getNumSuccessorOperands(unsigned index) {
    assert(!isKnownNonTerminator() && "only terminators may have successors");
    assert(index < getNumSuccessors());
    return getBlockOperands()[index].numSuccessorOperands;
  }

  Block *getSuccessor(unsigned index) {
    assert(index < getNumSuccessors());
    return getBlockOperands()[index].get();
  }
  void setSuccessor(Block *block, unsigned index);

  void eraseSuccessorOperand(unsigned succIndex, unsigned opIndex) {
    assert(succIndex < getNumSuccessors());
    assert(opIndex < getNumSuccessorOperands(succIndex));
    getOperandStorage().eraseOperand(getSuccessorOperandIndex(succIndex) +
                                     opIndex);
    --getBlockOperands()[succIndex].numSuccessorOperands;
  }

  unsigned getSuccessorOperandIndex(unsigned index);

  Optional<std::pair<unsigned, unsigned>>
  decomposeSuccessorOperandIndex(unsigned operandIndex);

  Optional<BlockArgument> getSuccessorBlockArgument(unsigned operandIndex) {
    auto decomposed = decomposeSuccessorOperandIndex(operandIndex);
    if (!decomposed.hasValue())
      return None;
    return getSuccessor(decomposed->first)->getArgument(decomposed->second);
  }

  //===--------------------------------------------------------------------===//
  // Accessors for various properties of operations
  //===--------------------------------------------------------------------===//

  bool isCommutative() {
    if (auto *absOp = getAbstractOperation())
      return absOp->hasProperty(OperationProperty::Commutative);
    return false;
  }

  bool hasNoSideEffect() {
    if (auto *absOp = getAbstractOperation())
      return absOp->hasProperty(OperationProperty::NoSideEffect);
    return false;
  }

  enum class TerminatorStatus { Terminator, NonTerminator, Unknown };

  TerminatorStatus getTerminatorStatus() {
    if (auto *absOp = getAbstractOperation()) {
      return absOp->hasProperty(OperationProperty::Terminator)
                 ? TerminatorStatus::Terminator
                 : TerminatorStatus::NonTerminator;
    }
    return TerminatorStatus::Unknown;
  }

  bool isKnownTerminator() {
    return getTerminatorStatus() == TerminatorStatus::Terminator;
  }

  bool isKnownNonTerminator() {
    return getTerminatorStatus() == TerminatorStatus::NonTerminator;
  }

  bool isKnownIsolatedFromAbove() {
    if (auto *absOp = getAbstractOperation())
      return absOp->hasProperty(OperationProperty::IsolatedFromAbove);
    return false;
  }

  LogicalResult fold(ArrayRef<Attribute> operands,
                     SmallVectorImpl<OpFoldResult> &results);

  template <template <typename T> class Trait> bool hasTrait() {
    auto *absOp = getAbstractOperation();
    return absOp ? absOp->hasTrait<Trait>() : false;
  }

  //===--------------------------------------------------------------------===//
  // Operation Walkers
  //===--------------------------------------------------------------------===//

  template <typename FnT, typename RetT = detail::walkResultType<FnT>>
  RetT walk(FnT &&callback) {
    return detail::walkOperations(this, std::forward<FnT>(callback));
  }

  //===--------------------------------------------------------------------===//
  // Other
  //===--------------------------------------------------------------------===//

  InFlightDiagnostic emitOpError(const Twine &message = {});

  InFlightDiagnostic emitError(const Twine &message = {});

  InFlightDiagnostic emitWarning(const Twine &message = {});

  InFlightDiagnostic emitRemark(const Twine &message = {});

private:
  //===--------------------------------------------------------------------===//
  // Ordering
  //===--------------------------------------------------------------------===//

  static constexpr unsigned kInvalidOrderIdx = -1;

  static constexpr unsigned kOrderStride = 5;

  void updateOrderIfNecessary();

  bool hasValidOrder() { return orderIndex != kInvalidOrderIdx; }

private:
  Operation(Location location, OperationName name, ArrayRef<Type> resultTypes,
            unsigned numSuccessors, unsigned numRegions,
            const NamedAttributeList &attributes);

  // Operations are deleted through the destroy() member because they are
  // allocated with malloc.
  ~Operation();

  detail::OperandStorage &getOperandStorage() {
    return *getTrailingObjects<detail::OperandStorage>();
  }

  detail::TrailingOpResult *getTrailingResult(unsigned trailingResultNumber) {
    return getTrailingObjects<detail::TrailingOpResult>() +
           trailingResultNumber;
  }

  Block *getParent() const { return block; }

  Block *block = nullptr;

  Location location;

  mutable unsigned orderIndex = 0;

  const unsigned numSuccs;
  const unsigned numRegions : 31;

  bool hasSingleResult : 1;
  Type resultType;

  OperationName name;

  NamedAttributeList attrs;

  // allow ilist_traits access to 'block' field.
  friend struct llvm::ilist_traits<Operation>;

  // allow block to access the 'orderIndex' field.
  friend class Block;

  // allow value to access the 'getTrailingResult' method.
  friend class Value;

  // allow ilist_node_with_parent to access the 'getParent' method.
  friend class llvm::ilist_node_with_parent<Operation, Block>;

  // This stuff is used by the TrailingObjects template.
  friend llvm::TrailingObjects<Operation, detail::TrailingOpResult,
                               BlockOperand, Region, detail::OperandStorage>;
  size_t numTrailingObjects(OverloadToken<detail::TrailingOpResult>) const {
    return OpResult::getNumTrailing(
        const_cast<Operation *>(this)->getNumResults());
  }
  size_t numTrailingObjects(OverloadToken<BlockOperand>) const {
    return numSuccs;
  }
  size_t numTrailingObjects(OverloadToken<Region>) const { return numRegions; }
};

inline raw_ostream &operator<<(raw_ostream &os, Operation &op) {
  op.print(os);
  return os;
}

} // end namespace mlir

namespace llvm {
template <typename T> struct isa_impl<T, ::mlir::Operation> {
  static inline bool doit(const ::mlir::Operation &op) {
    return T::classof(const_cast<::mlir::Operation *>(&op));
  }
};

template <typename T> struct cast_retty_impl<T, ::mlir::Operation *> {
  using ret_type = T;
};
template <typename T> struct cast_retty_impl<T, ::mlir::Operation> {
  using ret_type = T;
};
template <class T>
struct cast_convert_val<T, ::mlir::Operation, ::mlir::Operation> {
  static T doit(::mlir::Operation &val) { return T(&val); }
};
template <class T>
struct cast_convert_val<T, ::mlir::Operation *, ::mlir::Operation *> {
  static T doit(::mlir::Operation *val) { return T(val); }
};
} // end namespace llvm

#endif // MLIR_IR_OPERATION_H