apache · tqchen · Feb 21, 2026 · Feb 20, 2026
diff --git a/3rdparty/cutlass_fpA_intB_gemm b/3rdparty/cutlass_fpA_intB_gemm
diff --git a/3rdparty/nvbench/l2_cache_flush.h b/3rdparty/nvbench/l2_cache_flush.h
@@ -27,11 +27,11 @@
 namespace tvm {
 namespace runtime {
 
-#define CUDA_CALL(func)                                       \
-  {                                                           \
-    cudaError_t e = (func);                                   \
-    ICHECK(e == cudaSuccess || e == cudaErrorCudartUnloading) \
-        << "CUDA: " << cudaGetErrorString(e);                 \
+#define CUDA_CALL(func)                                               \
+  {                                                                   \
+    cudaError_t e = (func);                                           \
+    TVM_FFI_ICHECK(e == cudaSuccess || e == cudaErrorCudartUnloading) \
+        << "CUDA: " << cudaGetErrorString(e);                         \
   }
 
 class L2Flush {

diff --git a/apps/cpp_rpc/main.cc b/apps/cpp_rpc/main.cc
@@ -143,7 +143,7 @@ string GetCmdOption(int argc, char* argv[], string option, bool key = false) {
         return cmd;
       }
       // We assume "=" is the end of option.
-      ICHECK_EQ(*option.rbegin(), '=');
+      TVM_FFI_ICHECK_EQ(*option.rbegin(), '=');
       cmd = arg.substr(arg.find('=') + 1);
       return cmd;
     }

diff --git a/apps/cpp_rpc/rpc_env.cc b/apps/cpp_rpc/rpc_env.cc
@@ -157,7 +157,7 @@ RPCEnv::RPCEnv(const std::string& wd) {
                              std::string bin;
 
                              std::ifstream fs(file_name, std::ios::in | std::ios::binary);
-                             ICHECK(!fs.fail()) << "Cannot open " << file_name;
+                             TVM_FFI_ICHECK(!fs.fail()) << "Cannot open " << file_name;
                              fs.seekg(0, std::ios::end);
                              size_t size = static_cast<size_t>(fs.tellg());
                              fs.seekg(0, std::ios::beg);
@@ -199,7 +199,7 @@ std::vector<std::string> ListDir(const std::string& dirname) {
   DIR* dp = opendir(dirname.c_str());
   if (dp == nullptr) {
     int errsv = errno;
-    LOG(FATAL) << "ListDir " << dirname << " error: " << strerror(errsv);
+    TVM_FFI_THROW(InternalError) << "ListDir " << dirname << " error: " << strerror(errsv);
   }
   dirent* d;
   while ((d = readdir(dp)) != nullptr) {
@@ -220,7 +220,7 @@ std::vector<std::string> ListDir(const std::string& dirname) {
   HANDLE handle = FindFirstFileA(pattern.c_str(), &fd);
   if (handle == INVALID_HANDLE_VALUE) {
     const int errsv = GetLastError();
-    LOG(FATAL) << "ListDir " << dirname << " error: " << strerror(errsv);
+    TVM_FFI_THROW(InternalError) << "ListDir " << dirname << " error: " << strerror(errsv);
   }
   do {
     std::string filename = fd.cFileName;
@@ -235,7 +235,7 @@ std::vector<std::string> ListDir(const std::string& dirname) {
   } while (FindNextFileA(handle, &fd));
   FindClose(handle);
 #else
-  LOG(FATAL) << "Operating system not supported";
+  TVM_FFI_THROW(InternalError) << "Operating system not supported";
 #endif
   return vec;
 }
@@ -260,7 +260,7 @@ void LinuxShared(const std::string output, const std::vector<std::string>& files
   std::string err_msg;
   auto executed_status = support::Execute(cmd, &err_msg);
   if (executed_status) {
-    LOG(FATAL) << err_msg;
+    TVM_FFI_THROW(InternalError) << err_msg;
   }
 }
 #endif
@@ -285,7 +285,7 @@ void WindowsShared(const std::string& output, const std::vector<std::string>& fi
   std::string err_msg;
   const auto executed_status = support::Execute(cmd, &err_msg);
   if (executed_status) {
-    LOG(FATAL) << err_msg;
+    TVM_FFI_THROW(InternalError) << err_msg;
   }
 }
 #endif
@@ -301,7 +301,7 @@ void CreateShared(const std::string& output, const std::vector<std::string>& fil
 #elif defined(_WIN32)
   WindowsShared(output, files);
 #else
-  LOG(FATAL) << "Operating system not supported";
+  TVM_FFI_THROW(InternalError) << "Operating system not supported";
 #endif
 }
 
@@ -323,7 +323,7 @@ std::string BuildSharedLibrary(std::string file) {
     std::string err_msg;
     const int executed_status = support::Execute(cmd, &err_msg);
     if (executed_status) {
-      LOG(FATAL) << err_msg;
+      TVM_FFI_THROW(InternalError) << err_msg;
     }
     CreateShared(file_name, ListDir(tmp_dir));
     CleanDir(tmp_dir);

diff --git a/apps/cpp_rpc/rpc_server.cc b/apps/cpp_rpc/rpc_server.cc
@@ -262,15 +262,15 @@ class RPCServer {
       support::TCPSocket conn = listen_sock_.Accept(addr);
 
       int code = kRPCMagic;
-      ICHECK_EQ(conn.RecvAll(&code, sizeof(code)), sizeof(code));
+      TVM_FFI_ICHECK_EQ(conn.RecvAll(&code, sizeof(code)), sizeof(code));
       if (code != kRPCMagic) {
         conn.Close();
-        LOG(FATAL) << "Client connected is not TVM RPC server";
+        TVM_FFI_THROW(InternalError) << "Client connected is not TVM RPC server";
         continue;
       }
 
       int keylen = 0;
-      ICHECK_EQ(conn.RecvAll(&keylen, sizeof(keylen)), sizeof(keylen));
+      TVM_FFI_ICHECK_EQ(conn.RecvAll(&keylen, sizeof(keylen)), sizeof(keylen));
 
       const char* CLIENT_HEADER = "client:";
       const char* SERVER_HEADER = "server:";
@@ -282,10 +282,10 @@ class RPCServer {
         continue;
       }
 
-      ICHECK_NE(keylen, 0);
+      TVM_FFI_ICHECK_NE(keylen, 0);
       std::string remote_key;
       remote_key.resize(keylen);
-      ICHECK_EQ(conn.RecvAll(&remote_key[0], keylen), keylen);
+      TVM_FFI_ICHECK_EQ(conn.RecvAll(&remote_key[0], keylen), keylen);
 
       std::stringstream ssin(remote_key);
       std::string arg0;
@@ -297,16 +297,16 @@ class RPCServer {
 
       if (arg0 != expect_header) {
         code = kRPCMismatch;
-        ICHECK_EQ(conn.SendAll(&code, sizeof(code)), sizeof(code));
+        TVM_FFI_ICHECK_EQ(conn.SendAll(&code, sizeof(code)), sizeof(code));
         conn.Close();
         LOG(WARNING) << "Mismatch key from" << addr->AsString();
         continue;
       } else {
         code = kRPCSuccess;
-        ICHECK_EQ(conn.SendAll(&code, sizeof(code)), sizeof(code));
+        TVM_FFI_ICHECK_EQ(conn.SendAll(&code, sizeof(code)), sizeof(code));
         keylen = int(server_key.length());
-        ICHECK_EQ(conn.SendAll(&keylen, sizeof(keylen)), sizeof(keylen));
-        ICHECK_EQ(conn.SendAll(server_key.c_str(), keylen), keylen);
+        TVM_FFI_ICHECK_EQ(conn.SendAll(&keylen, sizeof(keylen)), sizeof(keylen));
+        TVM_FFI_ICHECK_EQ(conn.SendAll(server_key.c_str(), keylen), keylen);
         LOG(INFO) << "Connection success " << addr->AsString();
 #ifndef __ANDROID__
         ssin >> *opts;
@@ -343,7 +343,7 @@ class RPCServer {
     size_t pos = opts.rfind(option);
     if (pos != std::string::npos) {
       const std::string cmd = opts.substr(pos + option.size());
-      ICHECK(support::IsNumber(cmd)) << "Timeout is not valid";
+      TVM_FFI_ICHECK(support::IsNumber(cmd)) << "Timeout is not valid";
       return std::stoi(cmd);
     }
     return 0;

diff --git a/apps/cpp_rpc/rpc_tracker_client.h b/apps/cpp_rpc/rpc_tracker_client.h
@@ -84,9 +84,9 @@ class TrackerClient {
       tracker_sock_ = ConnectWithRetry();
 
       int code = kRPCTrackerMagic;
-      ICHECK_EQ(tracker_sock_.SendAll(&code, sizeof(code)), sizeof(code));
-      ICHECK_EQ(tracker_sock_.RecvAll(&code, sizeof(code)), sizeof(code));
-      ICHECK_EQ(code, kRPCTrackerMagic) << tracker_addr_.c_str() << " is not RPC Tracker";
+      TVM_FFI_ICHECK_EQ(tracker_sock_.SendAll(&code, sizeof(code)), sizeof(code));
+      TVM_FFI_ICHECK_EQ(tracker_sock_.RecvAll(&code, sizeof(code)), sizeof(code));
+      TVM_FFI_ICHECK_EQ(code, kRPCTrackerMagic) << tracker_addr_.c_str() << " is not RPC Tracker";
 
       std::ostringstream ss;
       ss << "[" << static_cast<int>(TrackerCode::kUpdateInfo) << ", {\"key\": \"server:" << key_
@@ -95,7 +95,7 @@ class TrackerClient {
 
       // Receive status and validate
       std::string remote_status = tracker_sock_.RecvBytes();
-      ICHECK_EQ(std::stoi(remote_status), static_cast<int>(TrackerCode::kSuccess));
+      TVM_FFI_ICHECK_EQ(std::stoi(remote_status), static_cast<int>(TrackerCode::kSuccess));
     }
   }
   /*!
@@ -124,7 +124,7 @@ class TrackerClient {
 
       // Receive status and validate
       std::string remote_status = tracker_sock_.RecvBytes();
-      ICHECK_EQ(std::stoi(remote_status), static_cast<int>(TrackerCode::kSuccess));
+      TVM_FFI_ICHECK_EQ(std::stoi(remote_status), static_cast<int>(TrackerCode::kSuccess));
     } else {
       *matchkey = key_;
     }
@@ -174,7 +174,7 @@ class TrackerClient {
             tracker_sock_.SendBytes(ss.str());
 
             std::string remote_status = tracker_sock_.RecvBytes();
-            ICHECK_EQ(std::stoi(remote_status), static_cast<int>(TrackerCode::kSuccess));
+            TVM_FFI_ICHECK_EQ(std::stoi(remote_status), static_cast<int>(TrackerCode::kSuccess));
             unmatch_period_count = 0;
           }
           continue;
@@ -206,7 +206,7 @@ class TrackerClient {
       auto period = (std::chrono::duration_cast<std::chrono::seconds>(
                          std::chrono::system_clock::now() - tbegin))
                         .count();
-      ICHECK(period < timeout) << "Failed to connect to server" << addr.AsString();
+      TVM_FFI_ICHECK(period < timeout) << "Failed to connect to server" << addr.AsString();
       LOG(WARNING) << "Cannot connect to tracker " << addr.AsString() << " retry in "
                    << retry_period << " seconds.";
       std::this_thread::sleep_for(std::chrono::seconds(retry_period));

diff --git a/apps/cpp_rpc/win32_process.cc b/apps/cpp_rpc/win32_process.cc
@@ -93,19 +93,19 @@ SOCKET GetSocket(const std::string& mmap_path) {
   UniqueHandle parent_file_mapping_event;
   if ((parent_file_mapping_event = MakeUniqueHandle(
            OpenEventA(SYNCHRONIZE, false, parent_event_name.c_str()))) == nullptr) {
-    LOG(FATAL) << "OpenEvent() failed: " << GetLastError();
+    TVM_FFI_THROW(InternalError) << "OpenEvent() failed: " << GetLastError();
   }
 
   UniqueHandle child_file_mapping_event;
   if ((child_file_mapping_event = MakeUniqueHandle(
            OpenEventA(EVENT_MODIFY_STATE, false, child_event_name.c_str()))) == nullptr) {
-    LOG(FATAL) << "OpenEvent() failed: " << GetLastError();
+    TVM_FFI_THROW(InternalError) << "OpenEvent() failed: " << GetLastError();
   }
 
   // Wait for the parent to set the event, notifying WSAPROTOCOL_INFO is ready to be read
   if (WaitForSingleObject(parent_file_mapping_event.get(), uint32_t(kEventTimeout.count())) !=
       WAIT_OBJECT_0) {
-    LOG(FATAL) << "WaitForSingleObject() failed: " << GetLastError();
+    TVM_FFI_THROW(InternalError) << "WaitForSingleObject() failed: " << GetLastError();
   }
 
   const UniqueHandle file_map =
@@ -129,7 +129,7 @@ SOCKET GetSocket(const std::string& mmap_path) {
     // Let the parent know we are finished duplicating the socket
     SetEvent(child_file_mapping_event.get());
   } else {
-    LOG(FATAL) << "MapViewOfFile() failed: " << GetLastError();
+    TVM_FFI_THROW(InternalError) << "MapViewOfFile() failed: " << GetLastError();
   }
 
   return sock_duplicated;
@@ -158,14 +158,14 @@ void SpawnRPCChild(SOCKET fd, seconds timeout) {
   UniqueHandle parent_file_mapping_event;
   if ((parent_file_mapping_event = MakeUniqueHandle(
            CreateEventA(nullptr, true, false, parent_event_name.c_str()))) == nullptr) {
-    LOG(FATAL) << "CreateEvent for parent file mapping failed";
+    TVM_FFI_THROW(InternalError) << "CreateEvent for parent file mapping failed";
   }
 
   UniqueHandle child_file_mapping_event;
   // An event to let the parent know the socket info was read from the mmap file
   if ((child_file_mapping_event = MakeUniqueHandle(
            CreateEventA(nullptr, true, false, child_event_name.c_str()))) == nullptr) {
-    LOG(FATAL) << "CreateEvent for child file mapping failed";
+    TVM_FFI_THROW(InternalError) << "CreateEvent for child file mapping failed";
   }
 
   char current_executable[MAX_PATH];
@@ -191,7 +191,7 @@ void SpawnRPCChild(SOCKET fd, seconds timeout) {
     WSAPROTOCOL_INFO protocol_info;
     // Get info needed to duplicate the socket
     if (WSADuplicateSocket(fd, child_process_info.dwProcessId, &protocol_info) == SOCKET_ERROR) {
-      LOG(FATAL) << "WSADuplicateSocket(): failed. Error =" << WSAGetLastError();
+      TVM_FFI_THROW(InternalError) << "WSADuplicateSocket(): failed. Error =" << WSAGetLastError();
     }
 
     // Create a mmap file to store the info needed for duplicating the SOCKET in the child proc
@@ -203,7 +203,7 @@ void SpawnRPCChild(SOCKET fd, seconds timeout) {
     }
 
     if (GetLastError() == ERROR_ALREADY_EXISTS) {
-      LOG(FATAL) << "CreateFileMapping(): mapping file already exists";
+      TVM_FFI_THROW(InternalError) << "CreateFileMapping(): mapping file already exists";
     } else {
       void* map_view = MapViewOfFile(file_map.get(), FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0);
 
@@ -218,12 +218,13 @@ void SpawnRPCChild(SOCKET fd, seconds timeout) {
         if (WaitForSingleObject(child_file_mapping_event.get(), uint32_t(kEventTimeout.count())) !=
             WAIT_OBJECT_0) {
           TerminateProcess(child_process_handle.get(), 0);
-          LOG(FATAL) << "WaitForSingleObject for child file mapping timed out.  Terminating child "
-                        "process.";
+          TVM_FFI_THROW(InternalError)
+              << "WaitForSingleObject for child file mapping timed out.  Terminating child "
+                 "process.";
         }
       } else {
         TerminateProcess(child_process_handle.get(), 0);
-        LOG(FATAL) << "MapViewOfFile() failed: " << GetLastError();
+        TVM_FFI_THROW(InternalError) << "MapViewOfFile() failed: " << GetLastError();
       }
     }
 
@@ -254,7 +255,7 @@ void ChildProcSocketHandler(const std::string& mmap_path) {
   if ((socket = GetSocket(mmap_path)) != INVALID_SOCKET) {
     tvm::runtime::ServerLoopFromChild(socket);
   } else {
-    LOG(FATAL) << "GetSocket() failed";
+    TVM_FFI_THROW(InternalError) << "GetSocket() failed";
   }
 }
 }  // namespace runtime

diff --git a/apps/hexagon_launcher/launcher_core.cc b/apps/hexagon_launcher/launcher_core.cc
@@ -182,7 +182,7 @@ tvm::runtime::Module load_module(const std::string& file_name) {
   static const tvm::ffi::Function loader = get_runtime_func("ffi.Module.load_from_file.hexagon");
   tvm::ffi::Any rv = loader(file_name);
   if (rv.type_code() == kTVMModuleHandle) {
-    ICHECK_EQ(rv.type_code(), kTVMModuleHandle)
+    TVM_FFI_ICHECK_EQ(rv.type_code(), kTVMModuleHandle)
         << __func__ << ": loaded " << file_name << ", but did not get module handle";
     return rv.operator tvm::runtime::Module();
   }

diff --git a/apps/hexagon_launcher/launcher_util.cc b/apps/hexagon_launcher/launcher_util.cc
@@ -42,7 +42,7 @@ size_t get_file_size(std::ifstream&& in_file) {
 std::string load_text_file(const std::string& file_name) {
   constexpr size_t block_size = 1024 * 1024;  // 1MB
   std::ifstream in_file(file_name);
-  ICHECK(in_file.is_open()) << "cannot open file " << file_name;
+  TVM_FFI_ICHECK(in_file.is_open()) << "cannot open file " << file_name;
   size_t file_size = get_file_size(in_file);
   std::string buffer(file_size + 1, 0);
 
@@ -52,7 +52,7 @@ std::string load_text_file(const std::string& file_name) {
 
 void* load_binary_file(const std::string& file_name, void* buffer, size_t buffer_size) {
   std::ifstream in_file(file_name);
-  ICHECK(in_file.is_open()) << "cannot open file " << file_name;
+  TVM_FFI_ICHECK(in_file.is_open()) << "cannot open file " << file_name;
   size_t file_size = get_file_size(in_file);
 
   in_file.read(reinterpret_cast<std::ifstream::char_type*>(buffer),
@@ -62,7 +62,7 @@ void* load_binary_file(const std::string& file_name, void* buffer, size_t buffer
 
 void write_binary_file(const std::string& file_name, void* buffer, size_t buffer_size) {
   std::ofstream out_file(file_name);
-  ICHECK(out_file.is_open()) << "cannot open file " << file_name;
+  TVM_FFI_ICHECK(out_file.is_open()) << "cannot open file " << file_name;
 
   out_file.write(reinterpret_cast<std::ofstream::char_type*>(buffer), buffer_size);
 }
diff --git a/include/tvm/arith/analyzer.h b/include/tvm/arith/analyzer.h
@@ -537,10 +537,10 @@ class TransitiveComparisonAnalyzer {
  *  arith::Analyzer analyzer;
  *  {
  *    With<arith::ConstraintContext> scope(&analyzer, x % 3 == 0);
- *    ICHECK_EQ(analyzer.modular_set(x)->coeff, 3);
+ *    TVM_FFI_ICHECK_EQ(analyzer.modular_set(x)->coeff, 3);
  *  }
  *  // constraint no longer in effect.
- *  ICHECK_NE(analyzer.modular_set(x)->coeff, 3);
+ *  TVM_FFI_ICHECK_NE(analyzer.modular_set(x)->coeff, 3);
  *
  * \endcode
  */

diff --git a/include/tvm/ir/attrs.h b/include/tvm/ir/attrs.h
@@ -384,7 +384,8 @@ template <typename DerivedType>
 class AttrsNodeReflAdapter : public BaseAttrsNode {
  public:
   void InitByPackedArgs(const ffi::PackedArgs& args, bool allow_unknown) final {
-    LOG(FATAL) << "`" << DerivedType::_type_key << "` uses new reflection mechanism for init";
+    TVM_FFI_THROW(InternalError) << "`" << DerivedType::_type_key
+                                 << "` uses new reflection mechanism for init";
   }
 
  private: