[FFI] Bump tvm-ffi to 63224e3 and fix regressions

include/tvm/script/ir_builder/relax/frame.h

@@ -125,9 +125,8 @@ class FunctionFrameNode : public SeqExprFrameNode {
         .def_ro("params", &FunctionFrameNode::params)
         .def_ro("ret_struct_info", &FunctionFrameNode::ret_struct_info)
         .def_ro("is_pure", &FunctionFrameNode::is_pure)
-        .def_ro("attrs", &FunctionFrameNode::attrs)
-        .def_ro("binding_blocks", &FunctionFrameNode::binding_blocks)
-        .def_ro("output", &FunctionFrameNode::output);
+        .def_ro("attrs", &FunctionFrameNode::attrs);
+    // `binding_blocks` and `output` are inherited from SeqExprFrameNode.
     // `block_builder` is not registered as it's not visited.
   }
   TVM_FFI_DECLARE_OBJECT_INFO_FINAL("script.ir_builder.relax.FunctionFrame", FunctionFrameNode,

python/tvm/ir/base.py

@@ -27,6 +27,14 @@
 class Node(Object):
     """Base class of all IR Nodes."""
 
+    def __repr__(self) -> str:
+        from tvm.runtime.script_printer import _script  # noqa: PLC0415
+
+        try:
+            return _script(self, None)
+        except Exception:  # noqa: BLE001
+            return super().__repr__()
+
 
 @register_object("ir.SourceMap")
 class SourceMap(Object):

python/tvm/ir/transform.py

@@ -147,6 +147,8 @@ class Pass(tvm.runtime.Object):
     conveniently interact with the base class.
     """
 
+    __slots__ = ("__dict__",)
+
     @property
     def info(self):
         """Get the pass meta."""

python/tvm/relax/binding_rewrite.py

@@ -38,6 +38,8 @@ class DataflowBlockRewrite(Object):
     use mutate_irmodule which rewrites the old function that registered in the constructor.
     """
 
+    __slots__ = ("__dict__",)
+
     def __init__(self, dfb: DataflowBlock, root_fn: Function):
         """
         Construct a rewriter with the DataflowBlock to rewrite and its root function.

python/tvm/relax/block_builder.py

@@ -153,6 +153,8 @@ class BlockBuilder(Object):
         mod = bb.get()
     """
 
+    __slots__ = ("__dict__",)
+
     _stack = []
 
     @staticmethod

python/tvm/runtime/support.py

@@ -149,6 +149,8 @@ def method(*args, **kwargs):
     class TVMDerivedObject(metadata["cls"]):  # type: ignore
         """The derived object to avoid cyclic dependency."""
 
+        __slots__ = ("__dict__", "__weakref__",)
+
         _cls = cls
         _type = "TVMDerivedObject"
 

python/tvm/s_tir/meta_schedule/utils.py

@@ -109,6 +109,8 @@ def method(*args, **kwargs):
     class TVMDerivedObject(metadata["cls"]):  # type: ignore
         """The derived object to avoid cyclic dependency."""
 
+        __slots__ = ("__dict__", "__weakref__",)
+
         _cls = cls
         _type = "TVMDerivedObject"
 

python/tvm/tirx/build.py

@@ -100,7 +100,7 @@ def main(self_handle: T.handle, args: T.handle, num_args: T.int32, result: T.han
 
     def is_host_func(f):
         target = f.attrs.get("target", tvm.target.Target("llvm"))
-        return str(target.kind) in ["llvm", "c"]
+        return target.kind.name in ["llvm", "c"]
 
     host_mod = tvm.tirx.transform.Filter(is_host_func)(mod)
     device_mod = tvm.tirx.transform.Filter(lambda f: not is_host_func(f))(mod)

src/ir/expr.cc

@@ -225,6 +225,10 @@ TVM_FFI_STATIC_INIT_BLOCK() {
         ss << ref;
         return ss.str();
       });
+  refl::TypeAttrDef<GlobalVarNode>().def(
+      refl::type_attr::kRepr, [](GlobalVar gvar, ffi::Function) -> ffi::String {
+        return "I.GlobalVar(\"" + std::string(gvar->name_hint) + "\")";
+      });
 }
 
 }  // namespace tvm

src/node/repr_printer.cc

@@ -22,11 +22,15 @@
  * \file node/repr_printer.cc
  */
 #include <tvm/ffi/function.h>
+#include <tvm/ffi/reflection/access_path.h>
 #include <tvm/ffi/reflection/registry.h>
 #include <tvm/node/cast.h>
 #include <tvm/node/repr_printer.h>
 #include <tvm/runtime/device_api.h>
 
+#include <sstream>
+#include <vector>
+
 #include "../support/str_escape.h"
 
 namespace tvm {
@@ -117,14 +121,66 @@ void Dump(const runtime::ObjectRef& n) { std::cerr << n << "\n"; }
 
 void Dump(const runtime::Object* n) { Dump(runtime::GetRef<runtime::ObjectRef>(n)); }
 
+namespace {
+/*!
+ * \brief Format an AccessStep as a concise string fragment.
+ *
+ * For map keys, uses ffi.ReprPrint which dispatches to __ffi_repr__.
+ */
+void FormatAccessStep(std::ostringstream& os, const ffi::reflection::AccessStep& step) {
+  using ffi::reflection::AccessKind;
+  static const ffi::Function repr_fn = ffi::Function::GetGlobal("ffi.ReprPrint").value();
+  switch (step->kind) {
+    case AccessKind::kAttr:
+      os << "." << step->key.cast<ffi::String>();
+      break;
+    case AccessKind::kArrayItem:
+      os << "[" << step->key.cast<int64_t>() << "]";
+      break;
+    case AccessKind::kMapItem:
+      os << "[" << repr_fn(step->key).cast<ffi::String>() << "]";
+      break;
+    case AccessKind::kAttrMissing:
+      os << "." << step->key.cast<ffi::String>() << "?";
+      break;
+    case AccessKind::kArrayItemMissing:
+      os << "[" << step->key.cast<int64_t>() << "]?";
+      break;
+    case AccessKind::kMapItemMissing:
+      os << "[" << repr_fn(step->key).cast<ffi::String>() << "]?";
+      break;
+  }
+}
+
+/*!
+ * \brief Format an AccessPath as "<root>.field[idx]".
+ */
+ffi::String FormatAccessPath(const ffi::reflection::AccessPath& path) {
+  std::vector<ffi::reflection::AccessStep> steps;
+  const ffi::reflection::AccessPathObj* cur = path.get();
+  while (cur->step.defined()) {
+    steps.push_back(cur->step.value());
+    cur = static_cast<const ffi::reflection::AccessPathObj*>(cur->parent.get());
+  }
+  std::ostringstream os;
+  os << "<root>";
+  for (auto it = steps.rbegin(); it != steps.rend(); ++it) {
+    FormatAccessStep(os, *it);
+  }
+  return os.str();
+}
+}  // namespace
+
 TVM_STATIC_IR_FUNCTOR(ReprPrinter, vtable)
     .set_dispatch<ffi::reflection::AccessPathObj>([](const ObjectRef& node, ReprPrinter* p) {
-      p->stream << Downcast<ffi::reflection::AccessPath>(node);
+      p->stream << FormatAccessPath(Downcast<ffi::reflection::AccessPath>(node));
     });
 
 TVM_STATIC_IR_FUNCTOR(ReprPrinter, vtable)
     .set_dispatch<ffi::reflection::AccessStepObj>([](const ObjectRef& node, ReprPrinter* p) {
-      p->stream << Downcast<ffi::reflection::AccessStep>(node);
+      std::ostringstream os;
+      FormatAccessStep(os, Downcast<ffi::reflection::AccessStep>(node));
+      p->stream << os.str();
     });
 
 TVM_FFI_STATIC_INIT_BLOCK() {
@@ -134,5 +190,19 @@ TVM_FFI_STATIC_INIT_BLOCK() {
     os << obj;
     return os.str();
   });
+  // Register __ffi_repr__ for AccessPath/AccessStep so that ffi.ReprPrint
+  // uses the concise "<root>.field[idx]" format instead of the dataclass repr.
+  refl::TypeAttrDef<ffi::reflection::AccessPathObj>().def(
+      refl::type_attr::kRepr,
+      [](ffi::reflection::AccessPath path, ffi::Function) -> ffi::String {
+        return FormatAccessPath(path);
+      });
+  refl::TypeAttrDef<ffi::reflection::AccessStepObj>().def(
+      refl::type_attr::kRepr,
+      [](ffi::reflection::AccessStep step, ffi::Function) -> ffi::String {
+        std::ostringstream os;
+        FormatAccessStep(os, step);
+        return os.str();
+      });
 }
 }  // namespace tvm

src/relax/ir/emit_te.h

@@ -44,12 +44,7 @@ class RXPlaceholderOpNode : public te::PlaceholderOpNode {
   static void RegisterReflection() {
     namespace refl = tvm::ffi::reflection;
     refl::ObjectDef<RXPlaceholderOpNode>()
-        .def_ro("name", &RXPlaceholderOpNode::name)
-        .def_ro("tag", &RXPlaceholderOpNode::tag)
-        .def_ro("attrs", &RXPlaceholderOpNode::attrs)
-        .def_ro("value", &RXPlaceholderOpNode::value)
-        .def_ro("shape", &RXPlaceholderOpNode::shape)
-        .def_ro("dtype", &RXPlaceholderOpNode::dtype);
+        .def_ro("value", &RXPlaceholderOpNode::value);
   }
 
   // FFI system configuration for structural equality and hashing

src/s_tir/schedule/instruction.cc

@@ -63,46 +63,49 @@ InstructionKindRegEntry& InstructionKindRegEntry::RegisterOrGet(const ffi::Strin
 
 /**************** Repr ****************/
 
+namespace {
+ffi::String InstructionAsPythonRepr(const InstructionNode* self) {
+  ffi::Array<Any> inputs;
+  inputs.reserve(self->inputs.size());
+  for (const Any& obj : self->inputs) {
+    if (obj == nullptr) {
+      inputs.push_back(ffi::String("None"));
+    } else if (auto opt_str = obj.as<ffi::String>()) {
+      inputs.push_back(ffi::String('"' + (*opt_str).operator std::string() + '"'));
+    } else if (obj.as<SBlockRVNode>() || obj.as<LoopRVNode>()) {
+      inputs.push_back(ffi::String("_"));
+    } else if (obj.type_index() < ffi::TypeIndex::kTVMFFISmallStr) {
+      inputs.push_back(obj);
+    } else if (obj.as<IntImmNode>() || obj.as<FloatImmNode>()) {
+      inputs.push_back(obj);
+    } else if (const auto* expr = obj.as<PrimExprNode>()) {
+      PrimExpr new_expr = Substitute(
+          ffi::GetRef<PrimExpr>(expr), [](const Var& var) -> ffi::Optional<PrimExpr> {
+            ObjectPtr<VarNode> new_var = ffi::make_object<VarNode>(*var.get());
+            new_var->name_hint = "_";
+            return Var(new_var);
+          });
+      std::ostringstream os;
+      os << new_expr;
+      inputs.push_back(ffi::String(os.str()));
+    } else if (obj.as<IndexMapNode>()) {
+      inputs.push_back(obj);
+    } else {
+      TVM_FFI_THROW(TypeError) << "Stringifying is not supported for type: " << obj.GetTypeKey();
+      throw;
+    }
+  }
+  return self->kind->f_as_python(
+      /*inputs=*/inputs,
+      /*attrs=*/self->attrs,
+      /*decision=*/Any(nullptr),
+      /*outputs=*/ffi::Array<ffi::String>(self->outputs.size(), ffi::String("_")));
+}
+}  // namespace
+
 TVM_STATIC_IR_FUNCTOR(ReprPrinter, vtable)
     .set_dispatch<InstructionNode>([](const ObjectRef& obj, ReprPrinter* p) {
-      const auto* self = obj.as<InstructionNode>();
-      TVM_FFI_ICHECK_NOTNULL(self);
-      ffi::Array<Any> inputs;
-      inputs.reserve(self->inputs.size());
-      for (const Any& obj : self->inputs) {
-        if (obj == nullptr) {
-          inputs.push_back(ffi::String("None"));
-        } else if (auto opt_str = obj.as<ffi::String>()) {
-          inputs.push_back(ffi::String('"' + (*opt_str).operator std::string() + '"'));
-        } else if (obj.as<SBlockRVNode>() || obj.as<LoopRVNode>()) {
-          inputs.push_back(ffi::String("_"));
-        } else if (obj.type_index() < ffi::TypeIndex::kTVMFFISmallStr) {
-          inputs.push_back(obj);
-        } else if (obj.as<IntImmNode>() || obj.as<FloatImmNode>()) {
-          inputs.push_back(obj);
-        } else if (const auto* expr = obj.as<PrimExprNode>()) {
-          PrimExpr new_expr = Substitute(
-              ffi::GetRef<PrimExpr>(expr), [](const Var& var) -> ffi::Optional<PrimExpr> {
-                ObjectPtr<VarNode> new_var = ffi::make_object<VarNode>(*var.get());
-                new_var->name_hint = "_";
-                return Var(new_var);
-              });
-          std::ostringstream os;
-          os << new_expr;
-          inputs.push_back(ffi::String(os.str()));
-        } else if (obj.as<IndexMapNode>()) {
-          inputs.push_back(obj);
-        } else {
-          TVM_FFI_THROW(TypeError)
-              << "Stringifying is not supported for type: " << obj.GetTypeKey();
-          throw;
-        }
-      }
-      p->stream << self->kind->f_as_python(
-          /*inputs=*/inputs,
-          /*attrs=*/self->attrs,
-          /*decision=*/Any(nullptr),
-          /*outputs=*/ffi::Array<ffi::String>(self->outputs.size(), ffi::String("_")));
+      p->stream << InstructionAsPythonRepr(obj.as<InstructionNode>());
     });
 
 /**************** FFI ****************/
@@ -116,6 +119,10 @@ TVM_FFI_STATIC_INIT_BLOCK() {
               ffi::Array<Any> outputs) -> Instruction {
              return Instruction(kind, inputs, attrs, outputs);
            });
+  refl::TypeAttrDef<InstructionNode>().def(
+      refl::type_attr::kRepr, [](Instruction inst, ffi::Function) -> ffi::String {
+        return InstructionAsPythonRepr(inst.get());
+      });
 }
 
 }  // namespace s_tir

src/s_tir/schedule/trace.cc

@@ -18,6 +18,8 @@
  */
 #include <tvm/ffi/reflection/registry.h>
 
+#include <sstream>
+
 #include "./utils.h"
 
 namespace tvm {
@@ -522,25 +524,31 @@ Trace TraceNode::Simplified(bool remove_postproc) const {
 
 /**************** Repr ****************/
 
+namespace {
+ffi::String TraceAsPythonRepr(const TraceNode* self) {
+  std::ostringstream os;
+  os << "# from tvm import s_tir\n";
+  os << "def apply_trace(sch: s_tir.Schedule) -> None:\n";
+  ffi::Array<ffi::String> repr = self->AsPython(/*remove_postproc=*/false);
+  bool is_first = true;
+  for (const ffi::String& line : repr) {
+    if (is_first) {
+      is_first = false;
+    } else {
+      os << '\n';
+    }
+    os << "  " << std::string(line);
+  }
+  if (is_first) {
+    os << "  pass";
+  }
+  return os.str();
+}
+}  // namespace
+
 TVM_STATIC_IR_FUNCTOR(ReprPrinter, vtable)
     .set_dispatch<TraceNode>([](const ObjectRef& obj, ReprPrinter* p) {
-      const auto* self = obj.as<TraceNode>();
-      TVM_FFI_ICHECK_NOTNULL(self);
-      p->stream << "# from tvm import s_tir\n";
-      p->stream << "def apply_trace(sch: s_tir.Schedule) -> None:\n";
-      ffi::Array<ffi::String> repr = self->AsPython(/*remove_postproc=*/false);
-      bool is_first = true;
-      for (const ffi::String& line : repr) {
-        if (is_first) {
-          is_first = false;
-        } else {
-          p->stream << '\n';
-        }
-        p->stream << "  " << line;
-      }
-      if (is_first) {
-        p->stream << "  pass";
-      }
+      p->stream << TraceAsPythonRepr(obj.as<TraceNode>());
       p->stream << std::flush;
     });
 
@@ -594,6 +602,10 @@ TVM_FFI_STATIC_INIT_BLOCK() {
       .def_method("s_tir.schedule.TraceWithDecision", &TraceNode::WithDecision)
       .def_method("s_tir.schedule.TraceSimplified", &TraceNode::Simplified)
       .def("s_tir.schedule.TraceApplyJSONToSchedule", Trace::ApplyJSONToSchedule);
+  // Register __ffi_repr__ so str(trace) returns the Python script format
+  refl::TypeAttrDef<TraceNode>().def(
+      refl::type_attr::kRepr,
+      [](Trace trace, ffi::Function) -> ffi::String { return TraceAsPythonRepr(trace.get()); });
 }
 
 }  // namespace s_tir

src/target/target.cc

@@ -479,7 +479,13 @@ TVM_FFI_STATIC_INIT_BLOCK() {
                return (*it).second;
              }
              return Any();
-           });
+           })
+      .def("target.TargetAsJSON",
+           [](const Target& target) -> ffi::String { return target->str(); });
+  // Register __ffi_repr__ so that ffi.ReprPrint uses JSON format for Target
+  refl::TypeAttrDef<TargetNode>().def(
+      refl::type_attr::kRepr,
+      [](Target target, ffi::Function) -> ffi::String { return target->str(); });
 }
 
 TVM_STATIC_IR_FUNCTOR(ReprPrinter, vtable)