OperationSupport.h

Go to the documentation of this file.

//===- OperationSupport.h ---------------------------------------*- 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 a number of support types that Operation and related
// classes build on top of.
//
//===----------------------------------------------------------------------===//

#ifndef MLIR_IR_OPERATION_SUPPORT_H
#define MLIR_IR_OPERATION_SUPPORT_H

#include "mlir/IR/Attributes.h"
#include "mlir/IR/Identifier.h"
#include "mlir/IR/Location.h"
#include "mlir/IR/Types.h"
#include "mlir/IR/Value.h"
#include "mlir/Support/LogicalResult.h"
#include "llvm/ADT/PointerUnion.h"
#include "llvm/Support/TrailingObjects.h"
#include <memory>

namespace mlir {
class Block;
class Dialect;
class Operation;
struct OperationState;
class OpAsmParser;
class OpAsmParserResult;
class OpAsmPrinter;
class OpFoldResult;
class ParseResult;
class Pattern;
class Region;
class RewritePattern;
class Type;
class Value;
class ValueRange;

template <typename OpTy> using OperandAdaptor = typename OpTy::OperandAdaptor;

class OwningRewritePatternList;

//===----------------------------------------------------------------------===//
// AbstractOperation
//===----------------------------------------------------------------------===//

enum class OperationProperty {
  Commutative = 0x1,

  NoSideEffect = 0x2,

  Terminator = 0x4,

  IsolatedFromAbove = 0x8,
};

class AbstractOperation {
public:
  using OperationProperties = uint32_t;

  const StringRef name;

  Dialect &dialect;

  bool (&classof)(Operation *op);

  ParseResult (&parseAssembly)(OpAsmParser &parser, OperationState &result);

  void (&printAssembly)(Operation *op, OpAsmPrinter &p);

  LogicalResult (&verifyInvariants)(Operation *op);

  LogicalResult (&foldHook)(Operation *op, ArrayRef<Attribute> operands,
                            SmallVectorImpl<OpFoldResult> &results);

  void (&getCanonicalizationPatterns)(OwningRewritePatternList &results,
                                      MLIRContext *context);

  bool hasProperty(OperationProperty property) const {
    return opProperties & static_cast<OperationProperties>(property);
  }

  template <typename T> typename T::Concept *getInterface() const {
    return reinterpret_cast<typename T::Concept *>(
        getRawInterface(T::getInterfaceID()));
  }

  template <template <typename T> class Trait> bool hasTrait() const {
    return hasRawTrait(ClassID::getID<Trait>());
  }

  static const AbstractOperation *lookup(StringRef opName,
                                         MLIRContext *context);

  template <typename T> static AbstractOperation get(Dialect &dialect) {
    return AbstractOperation(
        T::getOperationName(), dialect, T::getOperationProperties(), T::classof,
        T::parseAssembly, T::printAssembly, T::verifyInvariants, T::foldHook,
        T::getCanonicalizationPatterns, T::getRawInterface, T::hasTrait);
  }

private:
  AbstractOperation(
      StringRef name, Dialect &dialect, OperationProperties opProperties,
      bool (&classof)(Operation *op),
      ParseResult (&parseAssembly)(OpAsmParser &parser, OperationState &result),
      void (&printAssembly)(Operation *op, OpAsmPrinter &p),
      LogicalResult (&verifyInvariants)(Operation *op),
      LogicalResult (&foldHook)(Operation *op, ArrayRef<Attribute> operands,
                                SmallVectorImpl<OpFoldResult> &results),
      void (&getCanonicalizationPatterns)(OwningRewritePatternList &results,
                                          MLIRContext *context),
      void *(&getRawInterface)(ClassID *interfaceID),
      bool (&hasTrait)(ClassID *traitID))
      : name(name), dialect(dialect), classof(classof),
        parseAssembly(parseAssembly), printAssembly(printAssembly),
        verifyInvariants(verifyInvariants), foldHook(foldHook),
        getCanonicalizationPatterns(getCanonicalizationPatterns),
        opProperties(opProperties), getRawInterface(getRawInterface),
        hasRawTrait(hasTrait) {}

  const OperationProperties opProperties;

  void *(&getRawInterface)(ClassID *interfaceID);

  bool (&hasRawTrait)(ClassID *traitID);
};

//===----------------------------------------------------------------------===//
// OperationName
//===----------------------------------------------------------------------===//

class OperationName {
public:
  using RepresentationUnion =
      PointerUnion<Identifier, const AbstractOperation *>;

  OperationName(AbstractOperation *op) : representation(op) {}
  OperationName(StringRef name, MLIRContext *context);

  StringRef getDialect() const;

  StringRef getStringRef() const;

  const AbstractOperation *getAbstractOperation() const;

  void print(raw_ostream &os) const;
  void dump() const;

  void *getAsOpaquePointer() const {
    return static_cast<void *>(representation.getOpaqueValue());
  }
  static OperationName getFromOpaquePointer(void *pointer);

private:
  RepresentationUnion representation;
  OperationName(RepresentationUnion representation)
      : representation(representation) {}
};

inline raw_ostream &operator<<(raw_ostream &os, OperationName identifier) {
  identifier.print(os);
  return os;
}

inline bool operator==(OperationName lhs, OperationName rhs) {
  return lhs.getAsOpaquePointer() == rhs.getAsOpaquePointer();
}

inline bool operator!=(OperationName lhs, OperationName rhs) {
  return lhs.getAsOpaquePointer() != rhs.getAsOpaquePointer();
}

// Make operation names hashable.
inline llvm::hash_code hash_value(OperationName arg) {
  return llvm::hash_value(arg.getAsOpaquePointer());
}

//===----------------------------------------------------------------------===//
// OperationState
//===----------------------------------------------------------------------===//

struct OperationState {
  Location location;
  OperationName name;
  SmallVector<Value, 4> operands;
  SmallVector<Type, 4> types;
  SmallVector<NamedAttribute, 4> attributes;
  SmallVector<Block *, 1> successors;
  SmallVector<std::unique_ptr<Region>, 1> regions;
  bool resizableOperandList = false;

public:
  OperationState(Location location, StringRef name);

  OperationState(Location location, OperationName name);

  OperationState(Location location, StringRef name, ValueRange operands,
                 ArrayRef<Type> types, ArrayRef<NamedAttribute> attributes,
                 ArrayRef<Block *> successors = {},
                 MutableArrayRef<std::unique_ptr<Region>> regions = {},
                 bool resizableOperandList = false);

  void addOperands(ValueRange newOperands);

  void addTypes(ArrayRef<Type> newTypes) {
    types.append(newTypes.begin(), newTypes.end());
  }

  void addAttribute(StringRef name, Attribute attr) {
    addAttribute(Identifier::get(name, getContext()), attr);
  }

  void addAttribute(Identifier name, Attribute attr) {
    attributes.push_back({name, attr});
  }

  void addAttributes(ArrayRef<NamedAttribute> newAttributes) {
    attributes.append(newAttributes.begin(), newAttributes.end());
  }

  void addSuccessor(Block *successor, ValueRange succOperands);

  Region *addRegion();

  void addRegion(std::unique_ptr<Region> &&region);

  void setOperandListToResizable(bool isResizable = true) {
    resizableOperandList = isResizable;
  }

  MLIRContext *getContext() { return location->getContext(); }
};

//===----------------------------------------------------------------------===//
// OperandStorage
//===----------------------------------------------------------------------===//

namespace detail {
struct ResizableStorage {
  ResizableStorage(OpOperand *opBegin, unsigned numOperands)
      : firstOpAndIsDynamic(opBegin, false), capacity(numOperands) {}

  ~ResizableStorage() { cleanupStorage(); }

  void cleanupStorage() {
    // If the storage is dynamic, then we need to free the storage.
    if (isStorageDynamic())
      free(firstOpAndIsDynamic.getPointer());
  }

  void setDynamicStorage(OpOperand *opBegin) {
    cleanupStorage();
    firstOpAndIsDynamic.setPointerAndInt(opBegin, true);
  }

  OpOperand *getPointer() { return firstOpAndIsDynamic.getPointer(); }

  bool isStorageDynamic() const { return firstOpAndIsDynamic.getInt(); }

  llvm::PointerIntPair<OpOperand *, 1, bool> firstOpAndIsDynamic;

  // The maximum number of operands that can be currently held by the storage.
  unsigned capacity;
};

class OperandStorage final
    : private llvm::TrailingObjects<OperandStorage, ResizableStorage,
                                    OpOperand> {
public:
  OperandStorage(unsigned numOperands, bool resizable)
      : numOperands(numOperands), resizable(resizable) {
    // Initialize the resizable storage.
    if (resizable) {
      new (&getResizableStorage())
          ResizableStorage(getTrailingObjects<OpOperand>(), numOperands);
    }
  }

  ~OperandStorage() {
    // Manually destruct the operands.
    for (auto &operand : getOperands())
      operand.~OpOperand();

    // If the storage is resizable then destruct the utility.
    if (resizable)
      getResizableStorage().~ResizableStorage();
  }

  void setOperands(Operation *owner, ValueRange operands);

  void eraseOperand(unsigned index);

  MutableArrayRef<OpOperand> getOperands() {
    return {getRawOperands(), size()};
  }

  unsigned size() const { return numOperands; }

  static size_t additionalAllocSize(unsigned numOperands, bool resizable) {
    return additionalSizeToAlloc<ResizableStorage, OpOperand>(resizable ? 1 : 0,
                                                              numOperands);
  }

  bool isResizable() const { return resizable; }

private:
  void clear() { numOperands = 0; }

  OpOperand *getRawOperands() {
    return resizable ? getResizableStorage().getPointer()
                     : getTrailingObjects<OpOperand>();
  }

  ResizableStorage &getResizableStorage() {
    assert(resizable);
    return *getTrailingObjects<ResizableStorage>();
  }

  void grow(ResizableStorage &resizeUtil, size_t minSize);

  unsigned numOperands : 31;

  bool resizable : 1;

  // This stuff is used by the TrailingObjects template.
  friend llvm::TrailingObjects<OperandStorage, ResizableStorage, OpOperand>;
  size_t numTrailingObjects(OverloadToken<ResizableStorage>) const {
    return resizable ? 1 : 0;
  }
};
} // end namespace detail

//===----------------------------------------------------------------------===//
// TrailingOpResult
//===----------------------------------------------------------------------===//

namespace detail {
struct TrailingOpResult {
  uint64_t trailingResultNumber;
};
} // end namespace detail

//===----------------------------------------------------------------------===//
// OpPrintingFlags
//===----------------------------------------------------------------------===//

class OpPrintingFlags {
public:
  OpPrintingFlags();
  OpPrintingFlags(llvm::NoneType) : OpPrintingFlags() {}

  OpPrintingFlags &elideLargeElementsAttrs(int64_t largeElementLimit = 16);

  OpPrintingFlags &enableDebugInfo(bool prettyForm = false);

  OpPrintingFlags &printGenericOpForm();

  OpPrintingFlags &useLocalScope();

  bool shouldElideElementsAttr(ElementsAttr attr) const;

  bool shouldPrintDebugInfo() const;

  bool shouldPrintDebugInfoPrettyForm() const;

  bool shouldPrintGenericOpForm() const;

  bool shouldUseLocalScope() const;

private:
  Optional<int64_t> elementsAttrElementLimit;

  bool printDebugInfoFlag : 1;
  bool printDebugInfoPrettyFormFlag : 1;

  bool printGenericOpFormFlag : 1;

  bool printLocalScope : 1;
};

//===----------------------------------------------------------------------===//
// Operation Value-Iterators
//===----------------------------------------------------------------------===//

//===----------------------------------------------------------------------===//
// ValueTypeRange

template <typename ValueIteratorT>
class ValueTypeIterator final
    : public llvm::mapped_iterator<ValueIteratorT, Type (*)(Value)> {
  static Type unwrap(Value value) { return value.getType(); }

public:
  using reference = Type;

  Type operator*() const { return unwrap(*this->I); }

  ValueTypeIterator(ValueIteratorT it)
      : llvm::mapped_iterator<ValueIteratorT, Type (*)(Value)>(it, &unwrap) {}
};

//===----------------------------------------------------------------------===//
// OperandRange

class OperandRange final
    : public detail::indexed_accessor_range_base<OperandRange, OpOperand *,
                                                 Value, Value, Value> {
public:
  using RangeBaseT::RangeBaseT;
  OperandRange(Operation *op);

  using type_iterator = ValueTypeIterator<iterator>;
  iterator_range<type_iterator> getTypes() const { return {begin(), end()}; }

private:
  static OpOperand *offset_base(OpOperand *object, ptrdiff_t index) {
    return object + index;
  }
  static Value dereference_iterator(OpOperand *object, ptrdiff_t index) {
    return object[index].get();
  }

  friend RangeBaseT;
};

//===----------------------------------------------------------------------===//
// ResultRange

class ResultRange final
    : public indexed_accessor_range<ResultRange, Operation *, OpResult,
                                    OpResult, OpResult> {
public:
  using indexed_accessor_range<ResultRange, Operation *, OpResult, OpResult,
                               OpResult>::indexed_accessor_range;
  ResultRange(Operation *op);

  using type_iterator = ValueTypeIterator<iterator>;
  iterator_range<type_iterator> getTypes() const { return {begin(), end()}; }

private:
  static OpResult dereference(Operation *op, ptrdiff_t index);

  friend indexed_accessor_range<ResultRange, Operation *, OpResult, OpResult,
                                OpResult>;
};

//===----------------------------------------------------------------------===//
// ValueRange

namespace detail {
struct ValueRangeOwner {
  ValueRangeOwner(const Value *owner) : ptr(owner), startIndex(0) {}
  ValueRangeOwner(OpOperand *owner) : ptr(owner), startIndex(0) {}
  ValueRangeOwner(Operation *owner, unsigned startIndex)
      : ptr(owner), startIndex(startIndex) {}
  bool operator==(const ValueRangeOwner &rhs) const { return ptr == rhs.ptr; }

  PointerUnion<const Value *, OpOperand *, void *> ptr;

  unsigned startIndex;
};
} // end namespace detail

class ValueRange final
    : public detail::indexed_accessor_range_base<
          ValueRange, detail::ValueRangeOwner, Value, Value, Value> {
public:
  using RangeBaseT::RangeBaseT;

  template <typename Arg,
            typename = typename std::enable_if_t<
                std::is_constructible<ArrayRef<Value>, Arg>::value &&
                !std::is_convertible<Arg, Value>::value>>
  ValueRange(Arg &&arg) : ValueRange(ArrayRef<Value>(std::forward<Arg>(arg))) {}
  ValueRange(const Value &value) : ValueRange(&value, /*count=*/1) {}
  ValueRange(const std::initializer_list<Value> &values)
      : ValueRange(ArrayRef<Value>(values)) {}
  ValueRange(iterator_range<OperandRange::iterator> values)
      : ValueRange(OperandRange(values)) {}
  ValueRange(iterator_range<ResultRange::iterator> values)
      : ValueRange(ResultRange(values)) {}
  ValueRange(ArrayRef<Value> values = llvm::None);
  ValueRange(OperandRange values);
  ValueRange(ResultRange values);

  using type_iterator = ValueTypeIterator<iterator>;
  iterator_range<type_iterator> getTypes() const { return {begin(), end()}; }

private:
  using OwnerT = detail::ValueRangeOwner;

  static OwnerT offset_base(const OwnerT &owner, ptrdiff_t index);
  static Value dereference_iterator(const OwnerT &owner, ptrdiff_t index);

  friend RangeBaseT;
};
} // end namespace mlir

namespace llvm {
// Identifiers hash just like pointers, there is no need to hash the bytes.
template <> struct DenseMapInfo<mlir::OperationName> {
  static mlir::OperationName getEmptyKey() {
    auto pointer = llvm::DenseMapInfo<void *>::getEmptyKey();
    return mlir::OperationName::getFromOpaquePointer(pointer);
  }
  static mlir::OperationName getTombstoneKey() {
    auto pointer = llvm::DenseMapInfo<void *>::getTombstoneKey();
    return mlir::OperationName::getFromOpaquePointer(pointer);
  }
  static unsigned getHashValue(mlir::OperationName Val) {
    return DenseMapInfo<void *>::getHashValue(Val.getAsOpaquePointer());
  }
  static bool isEqual(mlir::OperationName LHS, mlir::OperationName RHS) {
    return LHS == RHS;
  }
};

template <> struct PointerLikeTypeTraits<mlir::OperationName> {
public:
  static inline void *getAsVoidPointer(mlir::OperationName I) {
    return const_cast<void *>(I.getAsOpaquePointer());
  }
  static inline mlir::OperationName getFromVoidPointer(void *P) {
    return mlir::OperationName::getFromOpaquePointer(P);
  }
  enum {
    NumLowBitsAvailable = PointerLikeTypeTraits<
        mlir::OperationName::RepresentationUnion>::NumLowBitsAvailable
  };
};

} // end namespace llvm

#endif