[FFI][REFACTOR] Update TVM_FFI_STATIC_INIT_BLOCK to fn style (#18312)

This PR updates TVM_FFI_STATIC_INIT_BLOCK to function style.
Now we do the code as follows, which is cleaner in generally
and also helps error reporting to locate the right place.

```
TVM_FFI_STATIC_INIT_BLOCK() {
  RegisterStaffs();
}
```

Author: tqchen

3rdparty/cutlass_fpA_intB_gemm

@@ -399,9 +399,9 @@ void RPCServerCreate(std::string host, int port, int port_end, std::string track
   rpc.Start();
 }
 
-TVM_FFI_STATIC_INIT_BLOCK({
+TVM_FFI_STATIC_INIT_BLOCK() {
   namespace refl = tvm::ffi::reflection;
   refl::GlobalDef().def("rpc.ServerCreate", RPCServerCreate);
-});
+}
 }  // namespace runtime
 }  // namespace tvm

apps/cpp_rpc/rpc_server.cc

@@ -52,7 +52,7 @@ void LogMessageImpl(const std::string& file, int lineno, int level, const std::s
 
 }  // namespace detail
 
-TVM_FFI_STATIC_INIT_BLOCK({
+TVM_FFI_STATIC_INIT_BLOCK() {
   namespace refl = tvm::ffi::reflection;
   refl::GlobalDef()
       .def_packed("tvm.rpc.server.workpath",
@@ -85,7 +85,7 @@ void LogMessageImpl(const std::string& file, int lineno, int level, const std::s
         *rv = Module::LoadFromFile(name, fmt);
         LOG(INFO) << "Load module from " << name << " ...";
       });
-});
+}
 
 #if defined(USE_CUSTOM_DSO_LOADER) && USE_CUSTOM_DSO_LOADER == 1
 
@@ -112,15 +112,15 @@ void Init(const std::string& name) {
 };
 
 // Add UnsignedDSOLoader plugin in global registry
-TVM_FFI_STATIC_INIT_BLOCK({
+TVM_FFI_STATIC_INIT_BLOCK() {
   namespace refl = tvm::ffi::reflection;
   refl::GlobalDef().def_packed("ffi.Module.load_from_file.dylib_custom",
                                [](ffi::PackedArgs args, ffi::Any* rv) {
                                  auto n = ffi::make_object<UnsignedDSOLoader>();
                                  n->Init(args[0]);
                                  *rv = tvm::ffi::CreateLibraryModule(n);
                                });
-});
+}
 
 #endif
 

apps/ios_rpc/tvmrpc/TVMRuntime.mm

@@ -153,10 +153,10 @@ then be registered with the following steps.
 
 #. Register the function to the tvm registry::
 
-     TVM_FFI_STATIC_INIT_BLOCK({
+     TVM_FFI_STATIC_INIT_BLOCK() {
        namespace refl = tvm::ffi::reflection;
        refl::GlobalDef().def("device_api.foo", FooDeviceAPI::Global);
-     });
+     }
 
 .. _base.h: https://github.com/apache/tvm/blob/main/include/tvm/runtime/base.h
 
@@ -228,10 +228,10 @@ the same name as was used in the ``TVM_REGISTER_TARGET_KIND``
 definition above. ::
 
   tvm::runtime::Module GeneratorFooCode(IRModule mod, Target target);
-  TVM_FFI_STATIC_INIT_BLOCK({
+  TVM_FFI_STATIC_INIT_BLOCK() {
     namespace refl = tvm::ffi::reflection;
     refl::GlobalDef().def("target.build.foo", GeneratorFooCode);
-  });
+  }
 
 The code generator takes two arguments.  The first is the ``IRModule``
 to compile, and the second is the ``Target`` that describes the device

docs/arch/device_target_interactions.rst

@@ -376,10 +376,10 @@ Python when needed.
       return CreateFunctionPass(pass_func, 0, "FoldConstant", {});
     }
 
-    TVM_FFI_STATIC_INIT_BLOCK({
+    TVM_FFI_STATIC_INIT_BLOCK() {
       namespace refl = tvm::ffi::reflection;
       refl::GlobalDef().def("relax.transform.FoldConstant", FoldConstant);
-    });
+    }
 
     }  // namespace transform
 

docs/arch/pass_infra.rst

@@ -80,10 +80,10 @@ The following example registers PackedFunc in C++ and calls from python.
 .. code:: c
 
     // register a global packed function in c++
-    TVM_FFI_STATIC_INIT_BLOCK({
+    TVM_FFI_STATIC_INIT_BLOCK() {
       namespace refl = tvm::ffi::reflection;
       refl::GlobalDef().def_packed("myadd", MyAdd);
-    });
+    }
 
 .. code:: python
 
@@ -112,13 +112,13 @@ we can pass functions from python (as PackedFunc) to C++.
 
 .. code:: c
 
-    TVM_FFI_STATIC_INIT_BLOCK({
+    TVM_FFI_STATIC_INIT_BLOCK() {
       namespace refl = tvm::ffi::reflection;
       refl::GlobalDef().def_packed("callhello", [](ffi::PackedArgs args, ffi::Any* rv) {
         ffi::Function f = args[0].cast<ffi::Function>();
         f("hello world");
       });
-    });
+    }
 
 .. code:: python
 
@@ -230,7 +230,7 @@ Each ``Object`` subclass will override this to register its members. Here is an
     TVM_FFI_DECLARE_OBJECT_INFO_FINAL("ir.IntImm", IntImmNode, PrimExprNode);
   };
   // in cc file
-  TVM_FFI_STATIC_INIT_BLOCK({ IntImmNode::RegisterReflection(); });
+  TVM_FFI_STATIC_INIT_BLOCK() { IntImmNode::RegisterReflection(); }
 
 The RegisterReflection gives us a reflection API to register each member of the object.
 We can use this function to visit the node and serialize any language object recursively.

docs/arch/runtime.rst

@@ -161,11 +161,11 @@ void RaiseError(ffi::String msg) {
   TVM_FFI_THROW(RuntimeError) << msg;
 }
 
-TVM_FFI_STATIC_INIT_BLOCK({
+TVM_FFI_STATIC_INIT_BLOCK() {
   namespace refl = tvm::ffi::reflection;
   refl::GlobalDef()
     .def("my_ffi_extension.raise_error", RaiseError);
-});
+}
 ```
 
 Make sure to have a unique name across all registered functions when registering a global function.

ffi/docs/guides/packaging.md

@@ -203,7 +203,7 @@ public:
   TVM_FFI_DEFINE_OBJECT_REF_METHODS_NULLABLE(TestIntPair, tvm::ffi::ObjectRef, TestIntPairObj);
 };
 
-TVM_FFI_STATIC_INIT_BLOCK({
+TVM_FFI_STATIC_INIT_BLOCK() {
   namespace refl = tvm::ffi::reflection;
   // register the object into the system
   // register field accessors and a global static function `__create__` as ffi::Function
@@ -213,7 +213,7 @@ TVM_FFI_STATIC_INIT_BLOCK({
     .def_static("__create__", [](int64_t a, int64_t b) -> TestIntPair {
       return TestIntPair(a, b);
     });
-});
+}
 ```
 
 You can then create wrapper classes for objects that are in the library as follows:

ffi/docs/guides/python_guide.md

@@ -62,7 +62,7 @@ TVM_FFI_DLL_EXPORT_TYPED_FUNC(add_one, my_ffi_extension::AddOne);
 
 // The static initialization block is
 // called once when the library is loaded.
-TVM_FFI_STATIC_INIT_BLOCK({
+TVM_FFI_STATIC_INIT_BLOCK() {
   namespace refl = tvm::ffi::reflection;
   // In this particular example, we use the reflection mechanisms to
   // register the functions directly into the global function table.
@@ -85,5 +85,5 @@ TVM_FFI_STATIC_INIT_BLOCK({
   // tvm::ffi::Module::LoadFromFile, instead, just load the dll or simply bundle into the
   // final project
   refl::GlobalDef().def("my_ffi_extension.raise_error", RaiseError);
-});
+}
 }  // namespace my_ffi_extension

ffi/examples/packaging/src/extension.cc

@@ -72,9 +72,6 @@
 #define TVM_FFI_UNREACHABLE() __builtin_unreachable()
 #endif
 
-/*! \brief helper macro to suppress unused warning */
-#define TVM_FFI_ATTRIBUTE_UNUSED [[maybe_unused]]
-
 #define TVM_FFI_STR_CONCAT_(__x, __y) __x##__y
 #define TVM_FFI_STR_CONCAT(__x, __y) TVM_FFI_STR_CONCAT_(__x, __y)
 
@@ -86,12 +83,39 @@
 #define TVM_FFI_FUNC_SIG __func__
 #endif
 
-#define TVM_FFI_STATIC_INIT_BLOCK_VAR_DEF \
-  TVM_FFI_ATTRIBUTE_UNUSED static inline int __##TVMFFIStaticInitReg
+#if defined(__GNUC__)
+// gcc and clang and attribute constructor
+/// \cond Doxygen_Suppress
+#define TVM_FFI_STATIC_INIT_BLOCK_DEF_(FnName) __attribute__((constructor)) static void FnName()
+/// \endcond
+/*
+ * \brief Macro that defines a block that will be called during static initialization.
+ *
+ * \code
+ * TVM_FFI_STATIC_INIT_BLOCK() {
+ *   RegisterFunctions();
+ * }
+ * \endcode
+ */
+#define TVM_FFI_STATIC_INIT_BLOCK() \
+  TVM_FFI_STATIC_INIT_BLOCK_DEF_(TVM_FFI_STR_CONCAT(__TVMFFIStaticInitFunc, __COUNTER__))
 
-/*! \brief helper macro to run code once during initialization */
-#define TVM_FFI_STATIC_INIT_BLOCK(Body) \
-  TVM_FFI_STR_CONCAT(TVM_FFI_STATIC_INIT_BLOCK_VAR_DEF, __COUNTER__) = []() { Body return 0; }()
+#else
+/// \cond Doxygen_Suppress
+// for other compilers, use the variable trick
+#define TVM_FFI_STATIC_INIT_BLOCK_DEF_(FnName, RegVar) \
+  static void FnName();                                \
+  [[maybe_unused]] static inline int RegVar = []() {   \
+    FnName();                                          \
+    return 0;                                          \
+  }();                                                 \
+  static void FnName()
+
+#define TVM_FFI_STATIC_INIT_BLOCK()                                                       \
+  TVM_FFI_STATIC_INIT_BLOCK_DEF_(TVM_FFI_STR_CONCAT(__TVMFFIStaticInitFunc, __COUNTER__), \
+                                 TVM_FFI_STR_CONCAT(__TVMFFIStaticInitReg, __COUNTER__))
+/// \endcond
+#endif
 
 /*
  * \brief Define the default copy/move constructor and assign operator