stmt.h

Go to the documentation of this file.

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
// Acknowledgement: Many low-level stmts originate from Halide.
#ifndef TVM_TIR_STMT_H_
#define TVM_TIR_STMT_H_
 
#include <tvm/ffi/reflection/registry.h>
#include <tvm/tir/expr.h>
 
#include <string>
#include <type_traits>
#include <utility>
 
namespace tvm {
namespace tir {
 
class StmtNode : public Object {
 public:
  mutable Span span;
 
  StmtNode() = default;
  explicit StmtNode(Span span) : span(span) {}
 
  static void RegisterReflection() {
    namespace refl = tvm::ffi::reflection;
    refl::ObjectDef<StmtNode>().def_ro("span", &StmtNode::span);
  }
 
  TVM_OBJECT_ENABLE_SCRIPT_PRINTER();
 
  static constexpr const char* _type_key = "tir.Stmt";
  static constexpr TVMFFISEqHashKind _type_s_eq_hash_kind = kTVMFFISEqHashKindTreeNode;
 
  static constexpr const uint32_t _type_child_slots = 15;
  TVM_DECLARE_BASE_OBJECT_INFO(StmtNode, Object);
};
 
class Stmt : public ObjectRef {
 public:
  TVM_DEFINE_OBJECT_REF_METHODS(Stmt, ObjectRef, StmtNode);
};
 
class LetStmtNode : public StmtNode {
 public:
  Var var;
  PrimExpr value;
  Stmt body;
 
  static void RegisterReflection() {
    namespace refl = tvm::ffi::reflection;
    refl::ObjectDef<LetStmtNode>()
        .def_ro("var", &LetStmtNode::var, refl::AttachFieldFlag::SEqHashDef())
        .def_ro("value", &LetStmtNode::value)
        .def_ro("body", &LetStmtNode::body);
  }
 
  static constexpr const char* _type_key = "tir.LetStmt";
  TVM_DECLARE_FINAL_OBJECT_INFO(LetStmtNode, StmtNode);
};
 
class LetStmt : public Stmt {
 public:
  TVM_DLL LetStmt(Var var, PrimExpr value, Stmt body, Span span = Span());
 
  TVM_DEFINE_OBJECT_REF_METHODS(LetStmt, Stmt, LetStmtNode);
  TVM_DEFINE_OBJECT_REF_COW_METHOD(LetStmtNode);
};
 
class AttrStmtNode : public StmtNode {
 public:
  ffi::Any node;
  String attr_key;
  PrimExpr value;
  Stmt body;
 
  static void RegisterReflection() {
    namespace refl = tvm::ffi::reflection;
    refl::ObjectDef<AttrStmtNode>()
        .def_ro("node", &AttrStmtNode::node)
        .def_ro("attr_key", &AttrStmtNode::attr_key)
        .def_ro("value", &AttrStmtNode::value)
        .def_ro("body", &AttrStmtNode::body);
  }
 
  static constexpr const char* _type_key = "tir.AttrStmt";
  TVM_DECLARE_FINAL_OBJECT_INFO(AttrStmtNode, StmtNode);
};
 
class AttrStmt : public Stmt {
 public:
  TVM_DLL AttrStmt(ffi::Any node, String attr_key, PrimExpr value, Stmt body, Span span = Span());
 
  TVM_DEFINE_OBJECT_REF_METHODS(AttrStmt, Stmt, AttrStmtNode);
  TVM_DEFINE_OBJECT_REF_COW_METHOD(AttrStmtNode);
};
 
class AssertStmtNode : public StmtNode {
 public:
  PrimExpr condition;
  PrimExpr message;
  Stmt body;
 
  static void RegisterReflection() {
    namespace refl = tvm::ffi::reflection;
    refl::ObjectDef<AssertStmtNode>()
        .def_ro("condition", &AssertStmtNode::condition)
        .def_ro("message", &AssertStmtNode::message)
        .def_ro("body", &AssertStmtNode::body);
  }
 
  static constexpr const char* _type_key = "tir.AssertStmt";
  TVM_DECLARE_FINAL_OBJECT_INFO(AssertStmtNode, StmtNode);
};
 
class AssertStmt : public Stmt {
 public:
  TVM_DLL AssertStmt(PrimExpr condition, PrimExpr message, Stmt body, Span span = Span());
 
  TVM_DEFINE_OBJECT_REF_METHODS(AssertStmt, Stmt, AssertStmtNode);
  TVM_DEFINE_OBJECT_REF_COW_METHOD(AssertStmtNode);
};
 
class BufferStoreNode : public StmtNode {
 public:
  Buffer buffer;
  PrimExpr value;
  Array<PrimExpr> indices;
  Optional<PrimExpr> predicate;
 
  static void RegisterReflection() {
    namespace refl = tvm::ffi::reflection;
    refl::ObjectDef<BufferStoreNode>()
        .def_ro("buffer", &BufferStoreNode::buffer)
        .def_ro("value", &BufferStoreNode::value)
        .def_ro("indices", &BufferStoreNode::indices)
        .def_ro("predicate", &BufferStoreNode::predicate);
  }
 
  static constexpr const char* _type_key = "tir.BufferStore";
  TVM_DECLARE_FINAL_OBJECT_INFO(BufferStoreNode, StmtNode);
};
 
class BufferStore : public Stmt {
 public:
  TVM_DLL explicit BufferStore(Buffer buffer, PrimExpr value, Array<PrimExpr> indices,
                               Optional<PrimExpr> predicate = std::nullopt, Span span = Span());
 
  TVM_DEFINE_OBJECT_REF_METHODS(BufferStore, Stmt, BufferStoreNode);
  TVM_DEFINE_OBJECT_REF_COW_METHOD(BufferStoreNode);
};
 
class BufferRealizeNode : public StmtNode {
 public:
  Buffer buffer;
  Array<Range> bounds;
  PrimExpr condition;
  Stmt body;
 
  static void RegisterReflection() {
    namespace refl = tvm::ffi::reflection;
    refl::ObjectDef<BufferRealizeNode>()
        .def_ro("buffer", &BufferRealizeNode::buffer)
        .def_ro("bounds", &BufferRealizeNode::bounds)
        .def_ro("condition", &BufferRealizeNode::condition)
        .def_ro("body", &BufferRealizeNode::body);
  }
 
  BufferRealizeNode() = default;
  BufferRealizeNode(Buffer buffer, Array<Range> bounds, PrimExpr condition, Stmt body,
                    Span span = Span())
      : StmtNode(span), buffer(buffer), bounds(bounds), condition(condition), body(body) {}
 
  static constexpr const char* _type_key = "tir.BufferRealize";
  TVM_DECLARE_FINAL_OBJECT_INFO(BufferRealizeNode, StmtNode);
};
 
class BufferRealize : public Stmt {
 public:
  TVM_DLL explicit BufferRealize(Buffer buffer, Array<Range> bounds, PrimExpr condition, Stmt body,
                                 Span span = Span());
 
  TVM_DEFINE_NOTNULLABLE_OBJECT_REF_METHODS(BufferRealize, Stmt, BufferRealizeNode);
  TVM_DEFINE_OBJECT_REF_COW_METHOD(BufferRealizeNode);
};
 
class AllocateNode : public StmtNode {
 public:
  Var buffer_var;
  DataType dtype;
  Array<PrimExpr> extents;
  PrimExpr condition;
  Stmt body;
  Map<String, ffi::Any> annotations;
 
  static void RegisterReflection() {
    namespace refl = tvm::ffi::reflection;
    refl::ObjectDef<AllocateNode>()
        .def_ro("buffer_var", &AllocateNode::buffer_var, refl::AttachFieldFlag::SEqHashDef())
        .def_ro("dtype", &AllocateNode::dtype)
        .def_ro("extents", &AllocateNode::extents)
        .def_ro("condition", &AllocateNode::condition)
        .def_ro("body", &AllocateNode::body)
        .def_ro("annotations", &AllocateNode::annotations);
  }
 
  int64_t ConstantAllocationSize() const { return ConstantAllocationSize(extents); }
  TVM_DLL static int64_t ConstantAllocationSize(const Array<PrimExpr>& extents);
 
  static constexpr const char* _type_key = "tir.Allocate";
 
  TVM_DECLARE_FINAL_OBJECT_INFO(AllocateNode, StmtNode);
};
 
class Allocate : public Stmt {
 public:
  TVM_DLL Allocate(Var buffer_var, DataType dtype, Array<PrimExpr> extents, PrimExpr condition,
                   Stmt body, Map<String, ffi::Any> annotations = Map<String, ffi::Any>(),
                   Span span = Span());
 
  TVM_DEFINE_OBJECT_REF_METHODS(Allocate, Stmt, AllocateNode);
  TVM_DEFINE_OBJECT_REF_COW_METHOD(AllocateNode);
};
 
class AllocateConstNode : public StmtNode {
 public:
  Var buffer_var;
  Optional<runtime::NDArray> data;
  Optional<Integer> irmod_storage_idx;
  DataType dtype;
  Array<PrimExpr> extents;
  Stmt body;
  Map<String, ffi::Any> annotations;
 
  static void RegisterReflection() {
    namespace refl = tvm::ffi::reflection;
    refl::ObjectDef<AllocateConstNode>()
        .def_ro("buffer_var", &AllocateConstNode::buffer_var, refl::AttachFieldFlag::SEqHashDef())
        .def_ro("data", &AllocateConstNode::data)
        .def_ro("irmod_storage_idx", &AllocateConstNode::irmod_storage_idx)
        .def_ro("dtype", &AllocateConstNode::dtype)
        .def_ro("extents", &AllocateConstNode::extents)
        .def_ro("body", &AllocateConstNode::body)
        .def_ro("annotations", &AllocateConstNode::annotations);
  }
 
  int64_t ConstantAllocationSize() const { return ConstantAllocationSize(extents); }
  TVM_DLL static int64_t ConstantAllocationSize(const Array<PrimExpr>& extents);
 
  static constexpr const char* _type_key = "tir.AllocateConst";
  TVM_DECLARE_FINAL_OBJECT_INFO(AllocateConstNode, StmtNode);
};
 
class AllocateConst : public Stmt {
 public:
  /* The constructor to create a IRNode with constant data
   * depending on the type of ObjectRef, it will either
   * create AllocateConstNode with irmod_storage_idx or data
   */
  TVM_DLL AllocateConst(Var buffer_var, DataType dtype, Array<PrimExpr> extents,
                        ObjectRef data_or_idx, Stmt body,
                        Map<String, ffi::Any> annotations = Map<String, ffi::Any>(),
                        Span span = Span());
  TVM_DEFINE_OBJECT_REF_METHODS(AllocateConst, Stmt, AllocateConstNode);
  TVM_DEFINE_OBJECT_REF_COW_METHOD(AllocateConstNode);
};
 
class DeclBufferNode : public StmtNode {
 public:
  Buffer buffer;
  Stmt body;
 
  static void RegisterReflection() {
    namespace refl = tvm::ffi::reflection;
    refl::ObjectDef<DeclBufferNode>()
        .def_ro("buffer", &DeclBufferNode::buffer)
        .def_ro("body", &DeclBufferNode::body);
  }
 
  static constexpr const char* _type_key = "tir.DeclBuffer";
  TVM_DECLARE_FINAL_OBJECT_INFO(DeclBufferNode, StmtNode);
};
 
class DeclBuffer : public Stmt {
 public:
  TVM_DLL DeclBuffer(Buffer buffer, Stmt body, Span span = Span());
  TVM_DEFINE_OBJECT_REF_METHODS(DeclBuffer, Stmt, DeclBufferNode);
  TVM_DEFINE_OBJECT_REF_COW_METHOD(DeclBufferNode);
};
 
class SeqStmtNode : public StmtNode {
 public:
  Array<Stmt> seq;
 
  size_t size() const { return seq.size(); }
  Stmt operator[](size_t index) const { return seq[index]; }
 
  static void RegisterReflection() {
    namespace refl = tvm::ffi::reflection;
    refl::ObjectDef<SeqStmtNode>().def_ro("seq", &SeqStmtNode::seq);
  }
 
  static constexpr const char* _type_key = "tir.SeqStmt";
  TVM_DECLARE_FINAL_OBJECT_INFO(SeqStmtNode, StmtNode);
};
 
class EvaluateNode : public StmtNode {
 public:
  PrimExpr value;
 
  static void RegisterReflection() {
    namespace refl = tvm::ffi::reflection;
    refl::ObjectDef<EvaluateNode>().def_ro("value", &EvaluateNode::value);
  }
 
  static constexpr const char* _type_key = "tir.Evaluate";
  TVM_DECLARE_FINAL_OBJECT_INFO(EvaluateNode, StmtNode);
};
 
class Evaluate : public Stmt {
 public:
  TVM_DLL explicit Evaluate(PrimExpr value, Span span = Span());
 
  explicit Evaluate(int value, Span span = Span()) : Evaluate(PrimExpr(value), span) {}
 
  TVM_DEFINE_OBJECT_REF_METHODS(Evaluate, Stmt, EvaluateNode);
  TVM_DEFINE_OBJECT_REF_COW_METHOD(EvaluateNode);
};
 
class SeqStmt : public Stmt {
 public:
  TVM_DLL explicit SeqStmt(Array<Stmt> seq, Span span = Span());
 
  size_t size() const { return operator->()->size(); }
  Stmt operator[](size_t index) const { return (*(operator->()))[index]; }
  template <typename... Args>
  static Stmt Flatten(Args&&... seq_args) {
    Array<Stmt> seq;
 
    ffi::details::for_each(Flattener(&seq), std::forward<Args>(seq_args)...);
 
    if (seq.empty()) {
      return Evaluate(0);
    } else if (seq.size() == 1) {
      return seq[0];
    }
 
    // If the argument is a single SeqStmt argument with no
    // flattening or unwrapping required, then we may
    // return the SeqStmt as-is.
    if constexpr (sizeof...(seq_args) == 1) {
      if (auto opt = Flattener::AsSeqStmt(std::forward<Args>(seq_args)...)) {
        SeqStmt original = opt.value();
        bool all_same = [&]() {
          if (original->seq.size() != seq.size()) {
            return false;
          }
          for (size_t i = 0; i < seq.size(); i++) {
            if (!original->seq[i].same_as(seq[i])) {
              return false;
            }
          }
          return true;
        }();
        if (all_same) {
          return original;
        }
      }
    }
 
    return SeqStmt(seq);
  }
  class Flattener {
   public:
    explicit Flattener(Array<Stmt>* seq) : seq_(seq) {}
 
    template <typename T>
    static Optional<SeqStmt> AsSeqStmt(const T& t) {
      if constexpr (std::is_same_v<T, SeqStmt>) {
        return t;
      }
      if constexpr (!std::is_base_of_v<T, SeqStmt>) {
        return std::nullopt;
      }
      if constexpr (std::is_base_of_v<Stmt, T>) {
        if (const SeqStmtNode* ptr = t.template as<SeqStmtNode>()) {
          return GetRef<SeqStmt>(ptr);
        } else {
          return std::nullopt;
        }
      }
      return std::nullopt;
    }
 
    template <typename T>
    void operator()(size_t i, const T& stmt_or_seq) const {
      if constexpr (std::is_base_of_v<ObjectRef, T>) {
        // Early bail-out, applicable to any ObjectRef
        if (!stmt_or_seq.defined()) {
          return;
        }
      }
 
      if constexpr (std::is_same_v<T, SeqStmt>) {
        // Static type-checking for a SeqStmt that could be flattened.
        (*this)(0, stmt_or_seq->seq);
        return;
      }
 
      if constexpr (std::is_base_of_v<T, SeqStmt>) {
        // Dynamic type-checking for a SeqStmt that could be
        // flattened.
        if (auto* op = stmt_or_seq.template as<SeqStmtNode>()) {
          operator()(0, op->seq);
          return;
        }
      }
 
      if constexpr (std::is_base_of_v<T, Evaluate>) {
        // Evaluate(0) is used to represent a no-op, and may be
        // generated by previous calls to SeqStmt::Flatten().  These
        // should be removed to ensure that Flatten(a+b) is equivalent
        // to Flatten(Flatten(a), Flatten(b)).
        if (auto* op = stmt_or_seq.template as<EvaluateNode>()) {
          if (auto* as_int = op->value.template as<IntImmNode>(); as_int && as_int->value == 0) {
            return;
          }
        }
      }
 
      if constexpr (std::is_base_of_v<Stmt, T>) {
        // Any other Stmt type just gets appended.
        seq_->push_back(stmt_or_seq);
      } else {
        // Anything else is treated as an iterable of Stmt.
        for (auto v : stmt_or_seq) {
          this->operator()(0, v);
        }
      }
    }
 
   private:
    Array<Stmt>* seq_;
  };
 
  TVM_DEFINE_OBJECT_REF_METHODS(SeqStmt, Stmt, SeqStmtNode);
  TVM_DEFINE_OBJECT_REF_COW_METHOD(SeqStmtNode);
};
 
class IfThenElseNode : public StmtNode {
 public:
  PrimExpr condition;
  Stmt then_case;
  Optional<Stmt> else_case;
 
  static void RegisterReflection() {
    namespace refl = tvm::ffi::reflection;
    refl::ObjectDef<IfThenElseNode>()
        .def_ro("condition", &IfThenElseNode::condition)
        .def_ro("then_case", &IfThenElseNode::then_case)
        .def_ro("else_case", &IfThenElseNode::else_case);
  }
 
  static constexpr const char* _type_key = "tir.IfThenElse";
  TVM_DECLARE_FINAL_OBJECT_INFO(IfThenElseNode, StmtNode);
};
 
class IfThenElse : public Stmt {
 public:
  TVM_DLL IfThenElse(PrimExpr condition, Stmt then_case, Optional<Stmt> else_case = std::nullopt,
                     Span span = Span());
 
  TVM_DEFINE_OBJECT_REF_METHODS(IfThenElse, Stmt, IfThenElseNode);
  TVM_DEFINE_OBJECT_REF_COW_METHOD(IfThenElseNode);
};
 
enum class ForKind : int {
  kSerial = 0,
  kParallel = 1,
  kVectorized = 2,
  kUnrolled = 3,
  kThreadBinding = 4
};
 
class ForNode : public StmtNode {
 public:
  Var loop_var;
  PrimExpr min;
  PrimExpr extent;
  ForKind kind;
  Stmt body;
  Optional<IterVar> thread_binding;
  Map<String, ffi::Any> annotations;
 
  static void RegisterReflection() {
    namespace refl = tvm::ffi::reflection;
    refl::ObjectDef<ForNode>()
        .def_ro("loop_var", &ForNode::loop_var, refl::AttachFieldFlag::SEqHashDef())
        .def_ro("min", &ForNode::min)
        .def_ro("extent", &ForNode::extent)
        .def_ro("kind", &ForNode::kind)
        .def_ro("body", &ForNode::body)
        .def_ro("thread_binding", &ForNode::thread_binding)
        .def_ro("annotations", &ForNode::annotations);
  }
 
  static constexpr const char* _type_key = "tir.For";
  TVM_DECLARE_FINAL_OBJECT_INFO(ForNode, StmtNode);
};
 
class For : public Stmt {
 public:
  TVM_DLL For(Var loop_var, PrimExpr min, PrimExpr extent, ForKind kind, Stmt body,
              Optional<IterVar> thread_binding = std::nullopt,
              Map<String, ffi::Any> annotations = Map<String, ffi::Any>(), Span span = Span());
 
  TVM_DEFINE_OBJECT_REF_METHODS(For, Stmt, ForNode);
  TVM_DEFINE_OBJECT_REF_COW_METHOD(ForNode);
};
 
class WhileNode : public StmtNode {
 public:
  PrimExpr condition;
  Stmt body;
 
  static void RegisterReflection() {
    namespace refl = tvm::ffi::reflection;
    refl::ObjectDef<WhileNode>()
        .def_ro("condition", &WhileNode::condition)
        .def_ro("body", &WhileNode::body);
  }
 
  static constexpr const char* _type_key = "tir.While";
  TVM_DECLARE_FINAL_OBJECT_INFO(WhileNode, StmtNode);
};
 
class While : public Stmt {
 public:
  TVM_DLL While(PrimExpr condition, Stmt body, Span span = Span());
 
  TVM_DEFINE_OBJECT_REF_METHODS(While, Stmt, WhileNode);
  TVM_DEFINE_OBJECT_REF_COW_METHOD(WhileNode);
};
 
class BufferRegionNode : public PrimExprConvertibleNode {
 public:
  Buffer buffer;
  Array<Range> region;
 
  static void RegisterReflection() {
    namespace refl = tvm::ffi::reflection;
    refl::ObjectDef<BufferRegionNode>()
        .def_ro("buffer", &BufferRegionNode::buffer)
        .def_ro("region", &BufferRegionNode::region);
  }
 
  TVM_DLL PrimExpr ToPrimExpr() const final;
 
  static constexpr const char* _type_key = "tir.BufferRegion";
  static constexpr TVMFFISEqHashKind _type_s_eq_hash_kind = kTVMFFISEqHashKindTreeNode;
  TVM_DECLARE_FINAL_OBJECT_INFO(BufferRegionNode, PrimExprConvertibleNode);
};
 
class BufferRegion : public PrimExprConvertible {
 public:
  TVM_DLL explicit BufferRegion(Buffer buffer, Array<Range> region);
 
  TVM_DLL static BufferRegion FullRegion(Buffer buffer);
 
  TVM_DLL static BufferRegion FromPoint(Buffer buffer, Array<PrimExpr> indices);
 
  TVM_DEFINE_OBJECT_REF_METHODS(BufferRegion, PrimExprConvertible, BufferRegionNode);
  TVM_DEFINE_OBJECT_REF_COW_METHOD(BufferRegionNode);
};
 
class MatchBufferRegionNode : public Object {
 public:
  Buffer buffer;
  BufferRegion source;
 
  static void RegisterReflection() {
    namespace refl = tvm::ffi::reflection;
    refl::ObjectDef<MatchBufferRegionNode>()
        .def_ro("buffer", &MatchBufferRegionNode::buffer)
        .def_ro("source", &MatchBufferRegionNode::source);
  }
 
  static constexpr const char* _type_key = "tir.MatchBufferRegion";
  static constexpr TVMFFISEqHashKind _type_s_eq_hash_kind = kTVMFFISEqHashKindTreeNode;
  TVM_DECLARE_FINAL_OBJECT_INFO(MatchBufferRegionNode, Object);
};
 
class MatchBufferRegion : public ObjectRef {
 public:
  TVM_DLL explicit MatchBufferRegion(Buffer buffer, BufferRegion source);
 
  TVM_DEFINE_OBJECT_REF_METHODS(MatchBufferRegion, ObjectRef, MatchBufferRegionNode);
  TVM_DEFINE_OBJECT_REF_COW_METHOD(MatchBufferRegionNode);
};
 
class BlockNode : public StmtNode {
 public:
  Array<IterVar> iter_vars;
  Array<BufferRegion> reads;
  Array<BufferRegion> writes;
  String name_hint;
  Array<Buffer> alloc_buffers;
  Array<MatchBufferRegion> match_buffers;
  Map<String, ffi::Any> annotations;
  Optional<Stmt> init;
  Stmt body;
 
  static void RegisterReflection() {
    namespace refl = tvm::ffi::reflection;
    refl::ObjectDef<BlockNode>()
        .def_ro("iter_vars", &BlockNode::iter_vars, refl::AttachFieldFlag::SEqHashDef())
        .def_ro("reads", &BlockNode::reads)
        .def_ro("writes", &BlockNode::writes)
        .def_ro("name_hint", &BlockNode::name_hint, refl::AttachFieldFlag::SEqHashIgnore())
        .def_ro("alloc_buffers", &BlockNode::alloc_buffers)
        .def_ro("match_buffers", &BlockNode::match_buffers)
        .def_ro("annotations", &BlockNode::annotations)
        .def_ro("init", &BlockNode::init)
        .def_ro("body", &BlockNode::body);
  }
 
  static constexpr const char* _type_key = "tir.Block";
  TVM_DECLARE_FINAL_OBJECT_INFO(BlockNode, StmtNode);
};
 
class Block : public Stmt {
 public:
  TVM_DLL explicit Block(Array<IterVar> iter_vars, Array<BufferRegion> reads,
                         Array<BufferRegion> writes, String name_hint, Stmt body,
                         Optional<Stmt> init = std::nullopt,
                         Array<Buffer> alloc_buffers = Array<Buffer>(),
                         Array<MatchBufferRegion> match_buffers = Array<MatchBufferRegion>(),
                         Map<String, ffi::Any> annotations = Map<String, ffi::Any>(),
                         Span span = Span());
 
  TVM_DEFINE_OBJECT_REF_METHODS(Block, Stmt, BlockNode);
  TVM_DEFINE_OBJECT_REF_COW_METHOD(BlockNode);
};
 
class BlockRealizeNode : public StmtNode {
 public:
  Array<PrimExpr> iter_values;
  PrimExpr predicate;
  Block block;
 
  static void RegisterReflection() {
    namespace refl = tvm::ffi::reflection;
    refl::ObjectDef<BlockRealizeNode>()
        .def_ro("iter_values", &BlockRealizeNode::iter_values)
        .def_ro("predicate", &BlockRealizeNode::predicate)
        .def_ro("block", &BlockRealizeNode::block);
  }
 
  static constexpr const char* _type_key = "tir.BlockRealize";
  TVM_DECLARE_FINAL_OBJECT_INFO(BlockRealizeNode, StmtNode);
};
 
class BlockRealize : public Stmt {
 public:
  TVM_DLL explicit BlockRealize(Array<PrimExpr> iter_values, PrimExpr predicate, Block block,
                                Span span = Span());
 
  TVM_DEFINE_OBJECT_REF_METHODS(BlockRealize, Stmt, BlockRealizeNode);
  TVM_DEFINE_OBJECT_REF_COW_METHOD(BlockRealizeNode);
};
 
namespace attr {
// The above attr does not pass to ir stage.
constexpr const char* thread_extent = "thread_extent";
constexpr const char* virtual_thread = "virtual_thread";
constexpr const char* coproc_scope = "coproc_scope";
constexpr const char* coproc_uop_scope = "coproc_uop_scope";
constexpr const char* volatile_scope = "volatile_scope";
constexpr const char* extern_scope = "extern_scope";
constexpr const char* compute_scope = "compute_scope";
constexpr const char* storage_alignment = "storage_alignment";
constexpr const char* realize_scope = "realize_scope";
constexpr const char* device_id = "device_id";
constexpr const char* device_type = "device_type";
constexpr const char* loop_scope = "loop_scope";
constexpr const char* reduce_scope = "reduce_scope";
constexpr const char* pragma_auto_unroll_max_step = "pragma_auto_unroll_max_step";
constexpr const char* pragma_unroll_explicit = "pragma_unroll_explicit";
constexpr const char* pragma_scope_prefix = "pragma_";
constexpr const char* pragma_import_c = "pragma_import_c";
constexpr const char* pragma_import_llvm = "pragma_import_llvm";
constexpr const char* pragma_tensor_core = "pragma_tensor_core";
constexpr const char* layout_transforms = "layout_transforms";
constexpr const char* axis_separators = "axis_separators";
constexpr const char* double_buffer_scope = "double_buffer_scope";
constexpr const char* double_buffer_write = "double_buffer_write";
constexpr const char* rolling_buffer_scope = "rolling_buffer_scope";
constexpr const char* scan_update_scope = "scan_update_scope";
constexpr const char* scan_init_scope = "scan_init_scope";
constexpr const char* buffer_dim_align = "buffer_dim_align";
constexpr const char* buffer_bound = "buffer_bound";
constexpr const char* buffer_bind_scope = "buffer_bind_scope";
// Pipeline related attributes
constexpr const char* channel_read_scope = "channel_read_scope";
constexpr const char* channel_read_advance = "channel_read_advance";
constexpr const char* channel_write_scope = "channel_write_scope";
constexpr const char* channel_write_advance = "channel_write_advance";
constexpr const char* pipeline_stage_scope = "pipeline_stage_scope";
constexpr const char* pipeline_exec_scope = "pipeline_exec_scope";
 
constexpr const char* device_scope = "device_scope";
 
constexpr const char* async_scope = "async_scope";
 
constexpr const char* async_commit_queue_scope = "async_commit_queue_scope";
constexpr const char* async_wait_queue_scope = "async_wait_queue_scope";
constexpr const char* async_wait_inflight_count = "async_wait_inflight_count";
 
constexpr const char* fragment_shape = "fragment_shape";
 
constexpr const char* fragment_layout = "fragment_layout";
 
constexpr const char* hand_threaded = "hand_threaded";
 
constexpr const char* script_parsing_detect_access = "tir.script_parsing_detect_access";
 
constexpr const char* pragma_loop_partition_hint = "pragma_loop_partition_hint";
 
constexpr const char* software_pipeline_stage = "software_pipeline_stage";
 
constexpr const char* software_pipeline_order = "software_pipeline_order";
 
constexpr const char* software_pipeline_async_stages = "software_pipeline_async_stages";
 
constexpr const char* layout_free_buffers = "layout_free_buffers";
 
constexpr const char* manifest_shared_memory_local_stage = "tir.manifest_shared_memory_local_stage";
 
constexpr const char* meta_schedule_tiling_structure = "meta_schedule.tiling_structure";
 
constexpr const char* meta_schedule_cooperative_fetch = "meta_schedule.cooperative_fetch";
 
constexpr const char* meta_schedule_thread_extent_low_inclusive =
    "meta_schedule.thread_extent_low_inclusive";
 
constexpr const char* meta_schedule_thread_extent_high_inclusive =
    "meta_schedule.thread_extent_high_inclusive";
 
constexpr const char* meta_schedule_random_compute_producer =
    "meta_schedule.random_compute_producer";
 
constexpr const char* meta_schedule_parallel = "meta_schedule.parallel";
 
constexpr const char* meta_schedule_vectorize = "meta_schedule.vectorize";
 
constexpr const char* meta_schedule_unroll_explicit = "meta_schedule.unroll_explicit";
 
constexpr const char* meta_schedule_unroll_implicit = "meta_schedule.unroll_implicit";
 
constexpr const char* meta_schedule_auto_tensorize = "meta_schedule.auto_tensorize";
 
constexpr const char* meta_schedule_layout_rewrite_preproc = "meta_schedule.layout_rewrite_preproc";
constexpr const char* meta_schedule_auto_tensorize_init = "meta_schedule.auto_tensorize_init";
 
constexpr const char* require_block_var_bound_predicate = "require_bound_predicate";
 
constexpr const char* meta_schedule_tensor_core_enabled = "meta_schedule.tensor_core_enabled";
 
constexpr const char* meta_schedule_cache_type = "meta_schedule.cache_type";
 
constexpr const int meta_schedule_cache_type_read = 0;
 
constexpr const int meta_schedule_cache_type_write = 1;
 
constexpr const char* auto_copy = "auto_copy";
 
constexpr const char* local_stage = "local_stage";
 
constexpr const char* vector_bytes = "vector_bytes";
 
constexpr const char* warp_execution = "warp_execution";
 
constexpr const char* meta_schedule_inline_rule = "meta_schedule.inline_rule";
 
constexpr const char* explicit_read_region = "explicit_read_region";
 
constexpr const char* explicit_write_region = "explicit_write_region";
 
inline bool IsPragmaKey(const std::string& attr_key) {
  return attr_key.compare(0, 7, "pragma_") == 0;
}
 
}  // namespace attr
TVM_DLL PrimExpr TypeAnnotation(DataType dtype, Span span = Span());
 
// overload printing of for type.
TVM_DLL std::ostream& operator<<(std::ostream& os, ForKind kind);
 
// inline implementations
inline const char* ForKind2String(ForKind t) {
  switch (t) {
    case ForKind::kSerial:
      return "serial";
    case ForKind::kParallel:
      return "parallel";
    case ForKind::kVectorized:
      return "vectorized";
    case ForKind::kUnrolled:
      return "unroll";
    case ForKind::kThreadBinding:
      return "thread_binding";
  }
  LOG(FATAL) << "Unknown ForKind" << t;
}
 
}  // namespace tir
}  // namespace tvm
#endif  // TVM_TIR_STMT_H_