chore: 移除 DDEBUG/MATCHDBG 调试日志残留

App/lib/StubGen/VpiReader.vp

@@ -3,7 +3,6 @@ from stdint import *
 import ast
 import string
 import stdlib
-import stdio
 import sys
 import memhub
 import llvmlite
@@ -379,17 +378,6 @@ def _resolve_vpi_ret_annot_str(pool: memhub.MemBuddy | t.CPtr,
     return None
 
 
-# ============================================================
-# _ddebug_exit - DDEBUG 拦截退出辅助函数
-#
-# 刷新 stderr 缓冲区并通过 VLogger 输出可见消息后退出。
-# 解决 sys.exit(1) 不刷新缓冲区导致 DDEBUG 消息丢失的问题。
-# ============================================================
-def _ddebug_exit() -> None:
-    stdio.fflush(stdio.stderr)
-    VLogger.error("DDEBUG intercept triggered - check stderr for details")
-
-
 # ============================================================
 # VpiReader - .vpi AST 解析器
 #
@@ -446,11 +434,6 @@ def _extract_sha1_from_path(vpi_path: str) -> str:
         return None
     string.strncpy(sha1_buf, vpi_path + sep_pos, SHA1_LEN)
     sha1_buf[SHA1_LEN] = '\0'
-    # DDEBUG: 检测从路径提取的 SHA1 是否带尾随点（>=17 字符），发现问题立即终止
-    _ext_sl: t.CSizeT = string.strlen(sha1_buf)
-    if _ext_sl >= 17:
-        stdio.printf("[DDEBUG] _extract_sha1_from_path too long: len=%d sha1='%s' path='%s'\n", _ext_sl, sha1_buf, vpi_path)
-        _ddebug_exit()
     return sha1_buf
 
 
@@ -649,25 +632,6 @@ def _inject_function_declare(pool: memhub.MemBuddy | t.CPtr,
     else:
         mangled_name = HandlesFunctions._mangle_name_with_sha1(src_sha1, fd.name)
 
-    # DDEBUG: VpiReader 是注入模块级函数 declare 的路径（无拦截，最可疑双点源头）
-    # 检测 src_sha1 带尾随点 / fd.name 带前导点 / mangled_name 含双点，发现立即终止
-    if mangled_name is not None and src_sha1 is not None and fd.name is not None:
-        _vpi_sl: t.CSizeT = string.strlen(src_sha1)
-        if _vpi_sl >= 17:
-            stdio.printf("[DDEBUG] VpiReader src_sha1 too long: len=%d sha1='%s' func='%s'\n", _vpi_sl, src_sha1, fd.name)
-            _ddebug_exit()
-        _vpi_fn_len: t.CSizeT = string.strlen(fd.name)
-        if _vpi_fn_len > 0 and fd.name[0] == '.':
-            stdio.printf("[DDEBUG] VpiReader fd.name starts with dot: name='%s' sha1='%s'\n", fd.name, src_sha1)
-            _ddebug_exit()
-        _vpi_mi: int = 0
-        _vpi_ml: t.CSizeT = string.strlen(mangled_name)
-        while _vpi_mi < _vpi_ml - 1:
-            if mangled_name[_vpi_mi] == 46 and mangled_name[_vpi_mi + 1] == 46:
-                stdio.printf("[DDEBUG] VpiReader mangled double-dot: sha1='%s' func='%s' mangled='%s'\n", src_sha1, fd.name, mangled_name)
-                _ddebug_exit()
-            _vpi_mi += 1
-
     # 去重：如果函数已存在则跳过
     existing: llvmlite.Function | t.CPtr = HandlesExprCall.find_func_in_module(mod, mangled_name)
     if existing is not None:

App/lib/core/Handles/HandlesExprCall.vp

@@ -4,7 +4,6 @@ import ast
 import llvmlite
 import memhub
 import string
-import stdio
 import stdlib
 import sys
 import viperlib
@@ -21,17 +20,6 @@ import lib.core.Handles.HandlesClassDef as HandlesClassDef
 import lib.core.StubMerger as StubMerger
 
 
-# ============================================================
-# _ddebug_exit - DDEBUG 拦截退出辅助函数
-#
-# 刷新 stderr 缓冲区并通过 VLogger 输出可见消息后退出。
-# 解决 sys.exit(1) 不刷新缓冲区导致 DDEBUG 消息丢失的问题。
-# ============================================================
-def _ddebug_exit() -> None:
-    stdio.fflush(stdio.stderr)
-    VLogger.error("DDEBUG intercept triggered - check stderr for details")
-
-
 # ============================================================
 # 模块 SHA1 查询（委托给 StubMerger 全局存储器）
 #
@@ -144,12 +132,6 @@ def _lookup_mod_sha1(pool: memhub.MemBuddy | t.CPtr,
     sha1: str = _lookup_module_sha1(base_mod)
     if sha1 is None:
         sha1 = _lookup_module_sha1_suffix(base_mod)
-    # DDEBUG: 检测 _lookup_mod_sha1 返回的 sha1 是否带尾随点（17 字符），发现问题立即终止
-    if sha1 is not None:
-        _sl: t.CSizeT = string.strlen(sha1)
-        if _sl >= 17:
-            stdio.printf("[DDEBUG] _lookup_mod_sha1 sha1 too long: len=%d sha1='%s' (class='%s' mod='%s')\n", _sl, sha1, class_name, base_mod)
-            _ddebug_exit()
     return sha1
 
 # ============================================================
@@ -4824,7 +4806,6 @@ def translate_call(pool: memhub.MemBuddy | t.CPtr,
                                 "类型 '%s' 已注册但大小为 0（字段链表未填充），立即终止编译",
                                 sz_cls_name)
                             VLogger.critical(fb_sz1, "__sizeof__")
-                        _ddebug_exit()
                     # 类型未注册：报错终止，不静默返回 0（会导致 malloc(0)/alloc(0) 堆溢出）
                     fb_sz2: t.CChar | t.CPtr = VLogger.fmt_buf()
                     if fb_sz2 is not None:
@@ -4832,7 +4813,6 @@ def translate_call(pool: memhub.MemBuddy | t.CPtr,
                             "类型 '%s' 未在结构体表中注册，无法计算大小，立即终止编译",
                             sz_cls_name)
                         VLogger.critical(fb_sz2, "__sizeof__")
-                    _ddebug_exit()
 
     # 检测 obj.__len__() — 返回 list 对象的 __count__ 字段（偏移 8，i64）
     # __len__ 是 list[T] 的内置方法，list 是泛型类不注册 struct
@@ -5571,13 +5551,6 @@ def translate_call(pool: memhub.MemBuddy | t.CPtr,
                             mangled: str = pool.alloc(mangled_len)
                             if mangled is not None:
                                 viperlib.snprintf(mangled, mangled_len, "%s.%s", mod_sha1, func_name)
-                                # DDEBUG: 检测连续两个点，发现立即终止
-                                _md_i: int = 0
-                                while _md_i < mangled_len - 1:
-                                    if mangled[_md_i] == 46 and mangled[_md_i + 1] == 46:
-                                        stdio.printf("[DDEBUG] mod mangled double-dot: sha1='%s' func='%s' mangled='%s'\n", mod_sha1, func_name, mangled)
-                                        _ddebug_exit()
-                                    _md_i += 1
                                 call_name = mangled
                     else:
                         # t 和 c 是内部库，豁免 SHA1 查找：使用裸名调用
@@ -5607,13 +5580,6 @@ def translate_call(pool: memhub.MemBuddy | t.CPtr,
                                         alias_mangled: str = pool.alloc(AliasMangledLen)
                                         if alias_mangled is not None:
                                             viperlib.snprintf(alias_mangled, AliasMangledLen, "%s.%s", alias_sha1, func_name)
-                                            # DDEBUG: 检测连续两个点，发现立即终止
-                                            _ad_i: int = 0
-                                            while _ad_i < AliasMangledLen - 1:
-                                                if alias_mangled[_ad_i] == 46 and alias_mangled[_ad_i + 1] == 46:
-                                                    stdio.printf("[DDEBUG] alias mangled double-dot: sha1='%s' func='%s' mangled='%s'\n", alias_sha1, func_name, alias_mangled)
-                                                    _ddebug_exit()
-                                                _ad_i += 1
                                             call_name = alias_mangled
                                 else:
                                     # 已导入模块但 SHA1 未注册：该模块未被编译，立即报错
@@ -5639,13 +5605,6 @@ def translate_call(pool: memhub.MemBuddy | t.CPtr,
                                         fmangled: str = pool.alloc(fmangled_len)
                                         if fmangled is not None:
                                             viperlib.snprintf(fmangled, fmangled_len, "%s.%s", from_sha1, func_name)
-                                            # DDEBUG: 检测连续两个点，发现立即终止
-                                            _fd_i: int = 0
-                                            while _fd_i < fmangled_len - 1:
-                                                if fmangled[_fd_i] == 46 and fmangled[_fd_i + 1] == 46:
-                                                    stdio.printf("[DDEBUG] from mangled double-dot: sha1='%s' func='%s' mangled='%s'\n", from_sha1, func_name, fmangled)
-                                                    _ddebug_exit()
-                                                _fd_i += 1
                                             call_name = fmangled
                                 else:
                                     err_msg2: t.CChar | t.CPtr = pool.alloc(256)
@@ -5693,13 +5652,6 @@ def translate_call(pool: memhub.MemBuddy | t.CPtr,
                         bare_mangled: str = pool.alloc(bare_mangled_len)
                         if bare_mangled is not None:
                             viperlib.snprintf(bare_mangled, bare_mangled_len, "%s.%s", bare_sha1, bare_func_name)
-                            # DDEBUG: 检测 bare_mangled 中连续两个点（非路径场景），发现立即终止
-                            _bd_i: int = 0
-                            while _bd_i < bare_mangled_len - 1:
-                                if bare_mangled[_bd_i] == 46 and bare_mangled[_bd_i + 1] == 46:
-                                    stdio.printf("[DDEBUG] bare_mangled double-dot: sha1='%s' func='%s' mangled='%s'\n", bare_sha1, bare_func_name, bare_mangled)
-                                    _ddebug_exit()
-                                _bd_i += 1
                             call_name = bare_mangled
                 else:
                     err_msg3: t.CChar | t.CPtr = pool.alloc(256)

App/lib/core/Handles/HandlesMatch.vp

@@ -4,7 +4,6 @@ import ast
 import llvmlite
 import memhub
 import string
-import stdio
 import viperlib
 import lib.core.Handles.HandlesBase as HandlesBase
 import lib.core.Handles.HandlesTranslator as HT
@@ -60,15 +59,6 @@ class MatchHandle(HandlesBase.Mixin):
         if builder is None or func is None:
             return 0
 
-        stdio.printf("[MATCHDBG] Handle entry: _renum_class_count=%d\n",
-                     HandlesClassDef._renum_class_count)
-        dbg_i: int = 0
-        while dbg_i < HandlesClassDef._renum_class_count:
-            dbg_nm: str = HandlesClassDef._renum_class_names[dbg_i]
-            if dbg_nm is not None:
-                stdio.printf("[MATCHDBG]   REnum[%d]=%s\n", dbg_i, dbg_nm)
-            dbg_i = dbg_i + 1
-
         m_node: ast.Match | t.CPtr = (ast.Match | t.CPtr)(node)
 
         # 1. 求值 subject
@@ -79,11 +69,8 @@ class MatchHandle(HandlesBase.Mixin):
             builder, pool, trans.Module, subject_node,
             trans._funcs, trans._func_count, trans)
         if subject_val is None:
-            stdio.printf("[MATCHDBG] subject_val is None (translate_value failed)\n")
             return 0
 
-        stdio.printf("[MATCHDBG] subject_val OK\n")
-
         # 2. 检测是否 REnum match
         is_renum: int = 0
         renum_name: str = None
@@ -93,23 +80,15 @@ class MatchHandle(HandlesBase.Mixin):
         if subject_node.kind() == ast.ASTKind.Name:
             nm: ast.Name | t.CPtr = (ast.Name | t.CPtr)(subject_node)
             if nm.id is not None:
-                stdio.printf("[MATCHDBG] subject Name='%s'\n", nm.id)
                 entry: HandlesVar.VarEntry | t.CPtr = HandlesVar.lookup_var_entry(
                     trans.SymTab, nm.id)
-                if entry is None:
-                    stdio.printf("[MATCHDBG] VarEntry None for '%s'\n", nm.id)
                 if entry is not None and entry.AnnotClassName is not None:
-                    stdio.printf("[MATCHDBG] AnnotClassName='%s'\n",
-                                 entry.AnnotClassName)
                     rn_chk: int = HandlesClassDef._is_renum_class_name(
                         entry.AnnotClassName)
-                    stdio.printf("[MATCHDBG] _is_renum_class_name=%d\n", rn_chk)
                     if rn_chk != 0:
                         is_renum = 1
                         renum_name = entry.AnnotClassName
                         subject_ptr = HandlesVar.lookup_var(trans.SymTab, nm.id)
-                        stdio.printf("[MATCHDBG] REnum detected: %s\n",
-                                     renum_name)
 
         # 2b. 若未确定，遍历 cases 查 MatchClass 变体
         if is_renum == 0:
@@ -136,11 +115,8 @@ class MatchHandle(HandlesBase.Mixin):
                     ci = ci + 1
 
         # 3. 分派
-        stdio.printf("[MATCHDBG] dispatch: is_renum=%d\n", is_renum)
         if is_renum != 0 and subject_ptr is not None:
-            stdio.printf("[MATCHDBG] -> _handle_renum_match\n")
             return self._handle_renum_match(m_node, renum_name, subject_ptr)
-        stdio.printf("[MATCHDBG] -> _handle_simple_match\n")
         return self._handle_simple_match(m_node, subject_val)
 
     # ============================================================
@@ -289,8 +265,6 @@ class MatchHandle(HandlesBase.Mixin):
                 renum_sty = renum_se.Ty
             if renum_sty is None:
                 # 找不到结构体类型时无法构造，直接放弃 REnum 路径
-                stdio.printf("[MATCHDBG] renum struct type not found for '%s'\n",
-                             renum_name)
                 return 0
             i64_ty0: llvmlite.LLVMType | t.CPtr = llvmlite.Int64(pool)
             int_val: llvmlite.Value | t.CPtr = subject_ptr
@@ -314,14 +288,11 @@ class MatchHandle(HandlesBase.Mixin):
         tag_ptr: llvmlite.Value | t.CPtr = llvmlite.build_bitcast(
             builder, subject_ptr, i32_ptr_ty)
         if tag_ptr is None:
-            stdio.printf("[MATCHDBG] tag_ptr None (bitcast failed)\n")
             return 0
         tag_val: llvmlite.Value | t.CPtr = llvmlite.build_load(
             builder, i32_ty, tag_ptr)
         if tag_val is None:
-            stdio.printf("[MATCHDBG] tag_val None (load failed)\n")
             return 0
-        stdio.printf("[MATCHDBG] _handle_renum_match: tag loaded OK\n")
 
         # 2. 创建 default/end BB
         cnt: int = trans._label_counter
@@ -381,10 +352,6 @@ class MatchHandle(HandlesBase.Mixin):
                     if vnm is not None:
                         tag: int = HandlesClassDef._lookup_renum_variant_in_class(
                             renum_name, vnm)
-                        stdio.printf("[MATCHDBG] case vnm='%s' renum='%s' -> tag=%d\n",
-                                     vnm if vnm is not None else "(null)",
-                                     renum_name if renum_name is not None else "(null)",
-                                     tag)
                         if tag >= 0:
                             tag_buf: t.CChar | t.CPtr = pool.alloc(32)
                             if tag_buf is not None:
@@ -631,8 +598,6 @@ class MatchHandle(HandlesBase.Mixin):
         builder: llvmlite.IRBuilder | t.CPtr = trans._cur_builder
         func: llvmlite.Function | t.CPtr = trans._cur_func
 
-        stdio.printf("[MATCHDBG] _handle_simple_match entry\n")
-
         # 1. subject 转 i32（若已 i32 直接用，否则 ptrtoint）
         i32_ty: llvmlite.LLVMType | t.CPtr = llvmlite.Int32(pool)
         subj_bits: int = HandlesExpr.get_llvm_type_bits(subject_val.Ty)

App/lib/core/StubMerger.vp

@@ -2,7 +2,6 @@ import t, c
 from stdint import *
 import memhub
 import string
-import stdio
 import stdlib
 import llvmlite
 import w32.win32file as win32file
@@ -21,17 +20,6 @@ import lib.StubGen.VpiReader as VpiReader
 import lib.Projectrans.Config as Config
 
 
-# ============================================================
-# _ddebug_exit - DDEBUG 拦截退出辅助函数
-#
-# 刷新 stderr 缓冲区并通过 VLogger 输出可见消息后退出。
-# 解决 sys.exit(1) 不刷新缓冲区导致 DDEBUG 消息丢失的问题。
-# ============================================================
-def _ddebug_exit() -> None:
-    stdio.fflush(stdio.stderr)
-    VLogger.error("DDEBUG intercept triggered - check stderr for details")
-
-
 # ============================================================
 # StubMerger - stub 声明合并模块
 #
@@ -377,11 +365,6 @@ def PopulateSha1MapStore(scan_result: IncludesScanner.ScanResult | t.CPtr) -> in
     global _sha1_store_arr, _sha1_store_mod, _sha1_store_rel, _sha1_store_count
     if scan_result is None:
         return -1
-    # [DDEBUG] 诊断：入口输出扫描条目数
-    fb_ps_in: t.CChar | t.CPtr = VLogger.fmt_buf()
-    if fb_ps_in is not None:
-        viperlib.snprintf(fb_ps_in, 1024, "PopulateSha1MapStore 入口: scan_result.Count=%d MAX_INCLUDES=%d", scan_result.Count, MAX_INCLUDES)
-        VLogger.warning(fb_ps_in, "Reachable")
     # 释放旧存储器
     if _sha1_store_arr is not None:
         stdlib.free(_sha1_store_arr)
@@ -399,59 +382,21 @@ def PopulateSha1MapStore(scan_result: IncludesScanner.ScanResult | t.CPtr) -> in
     string.memset(_sha1_store_rel, 0, MAX_INCLUDES * MAX_REL_PATH_LEN)
     _sha1_store_count = 0
     entry_size_p: t.CSizeT = IncludesScanner.FileEntry.__sizeof__()
-    # [DDEBUG] 诊断：循环前输出 range 参数和 entry_size
-    fb_rng: t.CChar | t.CPtr = VLogger.fmt_buf()
-    if fb_rng is not None:
-        viperlib.snprintf(fb_rng, 1024, "PopulateSha1MapStore 循环前: scan_result.Count=%d entry_size_p=%d", scan_result.Count, entry_size_p)
-        VLogger.warning(fb_rng, "Reachable")
     for i in range(scan_result.Count):
-        if i == 0:
-            # [DDEBUG] 诊断：确认循环体是否执行
-            fb_lp: t.CChar | t.CPtr = VLogger.fmt_buf()
-            if fb_lp is not None:
-                viperlib.snprintf(fb_lp, 1024, "PopulateSha1MapStore 进入循环体 i=0 (Count=%d)", scan_result.Count)
-                VLogger.warning(fb_lp, "Reachable")
         if _sha1_store_count >= MAX_INCLUDES:
-            # [DDEBUG] 诊断：break 触发
-            fb_brk: t.CChar | t.CPtr = VLogger.fmt_buf()
-            if fb_brk is not None:
-                viperlib.snprintf(fb_brk, 1024, "PopulateSha1MapStore break: _sha1_store_count=%d >= MAX_INCLUDES=%d (i=%d)", _sha1_store_count, MAX_INCLUDES, i)
-                VLogger.warning(fb_brk, "Reachable")
             break
         ea: t.CUInt64T = t.CUInt64T(scan_result.Entries) + i * entry_size_p
         ent: IncludesScanner.FileEntry | t.CPtr = (IncludesScanner.FileEntry | t.CPtr)(t.CVoid(ea, t.CPtr))
         if ent is None or ent.Sha1 is None or ent.RelPath is None:
-            # [DDEBUG] 诊断：跳过原因
-            fb_sk: t.CChar | t.CPtr = VLogger.fmt_buf()
-            if fb_sk is not None:
-                if ent is None:
-                    viperlib.snprintf(fb_sk, 1024, "PopulateSha1MapStore 跳过[%d]: ent=None", i)
-                elif ent.Sha1 is None:
-                    viperlib.snprintf(fb_sk, 1024, "PopulateSha1MapStore 跳过[%d]: Sha1=None", i)
-                else:
-                    viperlib.snprintf(fb_sk, 1024, "PopulateSha1MapStore 跳过[%d]: RelPath=None", i)
-                VLogger.warning(fb_sk, "Reachable")
             continue
         # 构建完整路径 includes/{RelPath}（_PathToModuleName 需要）
         rp_len: t.CSizeT = string.strlen(ent.RelPath)
         full_path_buf: bytes = stdlib.malloc(rp_len + 10)
         if full_path_buf is None:
-            # [DDEBUG] 诊断：malloc 返回 None 判断
-            if i < 3:
-                fb_fp: t.CChar | t.CPtr = VLogger.fmt_buf()
-                if fb_fp is not None:
-                    viperlib.snprintf(fb_fp, 1024, "PopulateSha1MapStore 跳过[%d]: full_path_buf is None (rp_len=%d)", i, rp_len)
-                    VLogger.warning(fb_fp, "Reachable")
             continue
         viperlib.snprintf(full_path_buf, rp_len + 10, "includes/%s", ent.RelPath)
         mod_name: str = _PathToModuleName(full_path_buf)
         stdlib.free(full_path_buf)
-        if mod_name is None:
-            # [DDEBUG] 诊断：_PathToModuleName 失败
-            fb_pn: t.CChar | t.CPtr = VLogger.fmt_buf()
-            if fb_pn is not None:
-                viperlib.snprintf(fb_pn, 1024, "PopulateSha1MapStore 跳过[%d]: _PathToModuleName 返回 None (RelPath=%s)", i, ent.RelPath)
-                VLogger.warning(fb_pn, "Reachable")
         if mod_name is not None:
             idx: t.CSizeT = t.CSizeT(_sha1_store_count) * 17
             string.strcpy(_sha1_store_arr + idx, ent.Sha1)
@@ -471,17 +416,6 @@ def PopulateSha1MapStore(scan_result: IncludesScanner.ScanResult | t.CPtr) -> in
                 string.strncpy(_sha1_store_rel + idx3, ent.RelPath, MAX_REL_PATH_LEN - 1)
                 _sha1_store_rel[idx3 + MAX_REL_PATH_LEN - 1] = '\0'
             _sha1_store_count += 1
-            # [DDEBUG] 诊断：+= 后的 count（确认是否写入全局）
-            if i < 3:
-                fb_inc: t.CChar | t.CPtr = VLogger.fmt_buf()
-                if fb_inc is not None:
-                    viperlib.snprintf(fb_inc, 1024, "PopulateSha1MapStore 填充[%d]: _sha1_store_count=%d", i, _sha1_store_count)
-                    VLogger.warning(fb_inc, "Reachable")
-    # [DDEBUG] 诊断：出口输出最终计数
-    fb_ps_out: t.CChar | t.CPtr = VLogger.fmt_buf()
-    if fb_ps_out is not None:
-        viperlib.snprintf(fb_ps_out, 1024, "PopulateSha1MapStore 出口: _sha1_store_count=%d", _sha1_store_count)
-        VLogger.warning(fb_ps_out, "Reachable")
     return _sha1_store_count
 
 
@@ -592,11 +526,6 @@ def LookupSha1ByModName(mod_name: str) -> str:
         idx_em: t.CSizeT = t.CSizeT(i_em) * 64
         if string.strcmp(_sha1_store_mod + idx_em, mod_name) == 0:
             sidx_em: t.CSizeT = t.CSizeT(i_em) * 17
-            # DDEBUG: 检测存储的 sha1 是否带尾随点（长度>=17），发现问题立即终止
-            _ck_len: t.CSizeT = string.strlen(_sha1_store_arr + sidx_em)
-            if _ck_len >= 17:
-                stdio.printf("[DDEBUG] StubMerger sha1 too long: len=%d sha1='%s' mod='%s'\n", _ck_len, _sha1_store_arr + sidx_em, mod_name)
-                _ddebug_exit()
             return _sha1_store_arr + sidx_em
     # 第二遍：包名回退（"ast" → "ast.__init__"）
     nm_len_em: t.CSizeT = string.strlen(mod_name)
@@ -1423,21 +1352,6 @@ def _BuildIncludesSha1Map(temp_dir: str, td_len: t.CSizeT,
     temp_dir/td_len 参数保留以兼容现有调用者，但不再使用。
     数据来源是 PopulateSha1MapStore 填充的全局存储器。
     """
-    # [DDEBUG] 诊断：入口输出全局存储器状态（区分填充失败/读取失败）
-    fb_bim: t.CChar | t.CPtr = VLogger.fmt_buf()
-    if fb_bim is not None:
-        viperlib.snprintf(fb_bim, 1024, "_BuildIncludesSha1Map 入口: _sha1_store_count=%d", _sha1_store_count)
-        VLogger.warning(fb_bim, "Reachable")
-    if _sha1_store_arr is None:
-        fb_na: t.CChar | t.CPtr = VLogger.fmt_buf()
-        if fb_na is not None:
-            viperlib.snprintf(fb_na, 1024, "_BuildIncludesSha1Map: _sha1_store_arr is None")
-            VLogger.warning(fb_na, "Reachable")
-    if _sha1_store_mod is None:
-        fb_nm: t.CChar | t.CPtr = VLogger.fmt_buf()
-        if fb_nm is not None:
-            viperlib.snprintf(fb_nm, 1024, "_BuildIncludesSha1Map: _sha1_store_mod is None")
-            VLogger.warning(fb_nm, "Reachable")
     if sha1_list is None or mod_list is None:
         return 0
     if _sha1_store_arr is None or _sha1_store_mod is None:
@@ -2080,7 +1994,6 @@ def BuildCombinedIR(temp_dir: str, local_sha1: str,
                         if fb is not None:
                             viperlib.snprintf(fb, 1024, "依赖模块 '%s' (sha1=%s) 的 stub 文件不存在: %s，立即终止编译", mod_nm, found_s, chk_path)
                             VLogger.error(fb, "BuildCombinedIR")
-                        _ddebug_exit()
                     chk_f.close()
                     stdlib.free(chk_path)
             stdlib.free(mod_nm)