Region.h

Go to the documentation of this file.

//===- Region.h - MLIR Region 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 Region class.
//
//===----------------------------------------------------------------------===//

#ifndef MLIR_IR_REGION_H
#define MLIR_IR_REGION_H

#include "mlir/IR/Block.h"

namespace mlir {
class BlockAndValueMapping;

class Region {
public:
  Region() = default;
  explicit Region(Operation *container);
  ~Region();

  MLIRContext *getContext();

  Location getLoc();

  using BlockListType = llvm::iplist<Block>;
  BlockListType &getBlocks() { return blocks; }

  // Iteration over the blocks in the region.
  using iterator = BlockListType::iterator;
  using reverse_iterator = BlockListType::reverse_iterator;

  iterator begin() { return blocks.begin(); }
  iterator end() { return blocks.end(); }
  reverse_iterator rbegin() { return blocks.rbegin(); }
  reverse_iterator rend() { return blocks.rend(); }

  bool empty() { return blocks.empty(); }
  void push_back(Block *block) { blocks.push_back(block); }
  void push_front(Block *block) { blocks.push_front(block); }

  Block &back() { return blocks.back(); }
  Block &front() { return blocks.front(); }

  static BlockListType Region::*getSublistAccess(Block *) {
    return &Region::blocks;
  }

  Region *getParentRegion();

  Operation *getParentOp();

  template <typename ParentT> ParentT getParentOfType() {
    auto *region = this;
    do {
      if (auto parent = dyn_cast_or_null<ParentT>(region->container))
        return parent;
    } while ((region = region->getParentRegion()));
    return ParentT();
  }

  unsigned getRegionNumber();

  bool isProperAncestor(Region *other);

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

  void cloneInto(Region *dest, BlockAndValueMapping &mapper);
  void cloneInto(Region *dest, Region::iterator destPos,
                 BlockAndValueMapping &mapper);

  void takeBody(Region &other) {
    blocks.clear();
    blocks.splice(blocks.end(), other.getBlocks());
  }

  bool isIsolatedFromAbove(Optional<Location> noteLoc = llvm::None);

  void dropAllReferences();

  template <typename FnT, typename RetT = detail::walkResultType<FnT>>
  typename std::enable_if<std::is_same<RetT, void>::value, RetT>::type
  walk(FnT &&callback) {
    for (auto &block : *this)
      block.walk(callback);
  }

  template <typename FnT, typename RetT = detail::walkResultType<FnT>>
  typename std::enable_if<std::is_same<RetT, WalkResult>::value, RetT>::type
  walk(FnT &&callback) {
    for (auto &block : *this)
      if (block.walk(callback).wasInterrupted())
        return WalkResult::interrupt();
    return WalkResult::advance();
  }

  void viewGraph(const Twine &regionName);
  void viewGraph();

private:
  BlockListType blocks;

  Operation *container;
};

class RegionRange
    : public detail::indexed_accessor_range_base<
          RegionRange, PointerUnion<Region *, const std::unique_ptr<Region> *>,
          Region *, Region *, Region *> {
  using OwnerT = PointerUnion<Region *, const std::unique_ptr<Region> *>;

public:
  using RangeBaseT::RangeBaseT;

  RegionRange(MutableArrayRef<Region> regions = llvm::None);

  template <typename Arg,
            typename = typename std::enable_if_t<std::is_constructible<
                ArrayRef<std::unique_ptr<Region>>, Arg>::value>>
  RegionRange(Arg &&arg)
      : RegionRange(ArrayRef<std::unique_ptr<Region>>(std::forward<Arg>(arg))) {
  }
  RegionRange(ArrayRef<std::unique_ptr<Region>> regions);

private:
  static OwnerT offset_base(const OwnerT &owner, ptrdiff_t index);
  static Region *dereference_iterator(const OwnerT &owner, ptrdiff_t index);

  friend RangeBaseT;
};

} // end namespace mlir

#endif // MLIR_IR_REGION_H