{"id":"9bee2d80-2002-4983-94e8-2637e5e18613","arxiv_id":"2608.10043","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":7.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":4,"one_line_summary":"N2NMatcher predicts inlining-stable anchor functions from binary graphs, decomposes binaries into anchor-bounded modules, and retrieves reused modules better than ModX on BinKit and ISRD.","lead":"A binary-analysis system learns which functions remain stable under compiler inlining and uses them as boundaries to split and match modules across compiled variants. It outperforms existing methods on same-project recompiles and improves cross-project library reuse detection, though absolute accuracy on cross-project cases remains limited.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"The decomposition-quality advantage is confounded: MDQ (Eq. 18) maxes over all reference modules and evaluates only overlap-eligible queries, so N2NMatcher's much coarser modules (Avg Size 6.49 vs ModX 1.50, Table II) can inflate Avg MDQ independent of boundary accuracy; Section VII concedes…","rationale":"The reader's conditional verdict is appropriate, but the single most load-bearing unresolved issue is not the debug-info oracle—it is the validity of the decomposition-quality metric itself. The oracle concern is real and acknowledged, yet it would affect both methods and all metrics; the MDQ confound directly targets the specific claim that anchor-bounded decomposition 'preserves source-level alignment... more effectively than the baseline decompositions' (Section V-B1). The metric's max-over-reference-modules definition and its restriction to overlap-eligible queries systematically favor the much coarser modules produced by N2NMatcher. This is not a speculative internal inconsistency: the paper itself concedes that Avg MDQ may favor coarse modules (Section VII), and the complementary Perfect metric goes the opposite direction. The proposed concrete test would settle whether the reported advantage survives a granularity-matched comparison. If it does not, the paper should not be accepted as-is; if it does, the concern is resolved. Either way, the conditional verdict remains the right recommendation until that check is run.","tokens_in":20923,"tokens_out":8601,"duration_ms":90153,"concrete_test":"Recompute Table II and Table III after size-matching modules across methods: either restrict all decompositions to modules with 2-5 functions, or replace max-over-reference-modules Dice with a one-to-one optimal assignment (e.g., Hungarian algorithm) on source-function sets and recompute Avg MDQ, Perfect, Recall@1, and MRR over the same query population. If N2NMatcher's advantage over ModX disappears or reverses, the central claim reduces to a granularity artifact.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The paper's strongest quantitative support for the decomposition-quality claim is Avg MDQ (Eq. 18), defined for each query module as the best Sørensen-Dice overlap with any reference module, averaged only over overlap-eligible queries (Eq. 19). This metric is not size-normalized and is not computed over comparable query sets across methods. N2NMatcher's modules average 6.49 recovered functions versus 1.50 for ModX and 8.88 for BMVul (Table II). For a coarse overlapping module, S_q is large, so the max over all reference modules tends to be higher and overlap eligibility is easier to satisfy; conversely, ModX's small modules are more likely to be excluded or to score low by construction. Table II's Perfect metric, which does not favor size, actually favors ModX and BMVul over N2NMatcher, and Section VII concedes that 'Avg MDQ may favor coarse modules.' Because the end-to-end matching metrics (Recall@k, MRR, Top-1 Sim) are computed only on each method's own overlap-eligible Q+ and use coarse query modules, the claimed module-matching improvements inherit the same granularity confound. Without controlling for module size or using a granularity-invariant alignment metric, the headline claim that anchor-bounded decomposition improves decomposition quality is not established.","agreement_with_reader":"partial"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper proposes N2NMatcher, a framework for binary decomposition and module matching intended to be resilient to function inlining. The authors first conduct an empirical study on BinKit LTO binaries with debug information, defining source-verified stable boundary functions and reporting that 42.67% of source-mapped FCG nodes are stable boundaries. They then train a hierarchical ACFG-FCG graph neural network to predict anchor nodes, decompose binaries by traversing from anchors and roots, and match the resulting modules using a combination of syntactic, semantic (learned module graph embedding), and graph similarity. Evaluation on BinKit and on an ISRD-derived corpus reports improvements over ModX in decomposition quality (Avg MDQ) and module matching (Top-1 Similarity, Recall@k, MRR), plus an ablation study and runtime measurements.","tokens_in":21254,"tokens_out":3548,"duration_ms":35596,"significance":"If the decomposition and matching claims hold, N2NMatcher would be a meaningful step toward program-level binary similarity under inlining, a problem that clearly matters for vulnerability search and library reuse detection. The paper has concrete strengths: the anchor concept is well motivated by a source-grounded study; the pipeline is described in detail; project-level cross-validation is used with configurations selected only on validation folds; the implementation is promised on GitHub; and the limitations of debug-line oracles and of the Avg MDQ metric are candidly acknowledged. The central issue is that the quantitative evidence for the decomposition-quality claim is confounded by module granularity, and the ground-truth oracle assumptions are load-bearing and not independently validated.","major_comments":[{"comment":"The decomposition-quality claim in the Abstract and in Section V-B1 rests on Avg MDQ computed only over overlap-eligible queries Q+. This metric is not size-normalized, and Table II shows that N2NMatcher's modules average 6.49 recovered functions versus 1.50 for ModX. Because MDQ takes the maximum Dice overlap with any reference module, larger query modules tend to have larger S_q, making high overlap easier to achieve and eligibility easier to satisfy by construction. The paper itself concedes in Section VII that \"Avg MDQ may favor coarse modules,\" and Table II's Perfect metric, which does not share this size bias, favors ModX or BMVul in two of the three settings. The claimed advantage in decomposition quality is therefore not established. I ask the authors to report a granularity-controlled evaluation, for example MDQ stratified by module size, a size-matched comparison, or a boundary-alignment metric that does not depend on module size, and to reconsider the decomposition claim in light of the Perfect results.","section":"V-B1, Eq. (18)-(19), Table II"},{"comment":"A load-bearing assumption is the origin-source-function (OSF) convention: when a binary function maps to multiple source functions, the source function whose name matches the binary function name is treated as the caller-side OSF. This assumption is not validated, and the paper acknowledges in Section VII that debug-line mappings may be incomplete under optimization. Because the same oracle produces the anchor labels, the 42.67% stable-boundary statistic, the MDQ ground truth, and the module-matching relevance labels, a systematic error in the naming convention would propagate into every reported result. I request a validation of the OSF naming assumption on a manually inspected subset or against an independent oracle (e.g., DWARF call-site information or source-level inlining lists), with error rates reported per optimization level and compiler.","section":"III-D, Definition 1, IV-C"},{"comment":"The end-to-end module matching metrics are computed only over each method's own overlap-eligible queries Q+ (Eq. 19), and the query modules are the same coarse modules used in the MDQ evaluation. Since N2NMatcher's modules are about four times larger than ModX's, its Q+ is likely to contain modules that are easier to match by construction, and the Top-1 Similarity and Recall@k improvements in Table III may partially reflect granularity rather than better boundary placement or better semantic matching. I ask for a matching evaluation on a granularity-invariant evaluation unit, such as source-function-seeded regions of fixed size, or at least a report of the results stratified by module size, so that the module-matching claim can be separated from the decomposition granularity confound.","section":"V-B2, Eqs. (20)-(21), Table III"}],"minor_comments":[{"comment":"The definition of B_inl_c(s) uses \"s is not the OSF but is inlined into the function whose OSF is o(b)\"; this is clear for the single-OSF convention, but the case where a binary function maps to multiple source functions and none matches the binary name is not discussed. Please clarify how such functions are handled and whether they are excluded from labeling.","section":"III-D, Eq. (3)"},{"comment":"The symbol alpha is used both for the positive-class weight in the anchor-prediction loss (Eq. 9) and for the Syntactic Similarity weight in the matching score (Eq. 12). Please rename one of them to avoid confusion.","section":"Eqs. (9), (12)"},{"comment":"The motivating example would be easier to follow if the figure explicitly marked which source functions are inlined and which are stable boundaries, and if the arrows between the two binary columns were described in the caption.","section":"I, Figure 1"},{"comment":"The description of validation says configurations are selected on validation folds, but Table I reports a single threshold of 0.4. Please state whether the threshold and the matching weights are selected per fold or globally, and whether the reported test results were obtained with fold-specific configurations.","section":"V-A4"},{"comment":"The related-work discussion would benefit from a more explicit comparison of N2NMatcher's anchor definition with the function-pair anchors used in ISRD, LibDB, and LibAM; as written, the reader must infer the distinction between source-verified stable boundaries and similarity-based anchor pairs.","section":"II-A, References [7]-[15]"}],"recommendation":"major_revision","confidential_remarks":"The granularity confound in Avg MDQ is the main blocker: the paper's own disclosure of this limitation in Section VII is commendable, but the headline decomposition claim cannot stand without a size-controlled metric. The oracle-assumption issue is also worth pressing, though it may be addressable with a focused validation study. If the authors fix the evaluation, the paper could be acceptable at a strong venue."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"The paper is worth serious referee time. The empirical finding is the real contribution: across the BinKit LTO set, 42.67% of source-labeled functions remain caller-side stable boundaries even under O3, and region-level source overlap can be preserved at mean 0.938 across compilation variants. That is a concrete, falsifiable observation that directly challenges the assumption that inlining destroys module boundaries. The anchor-bounded decomposition and the hierarchical ACFG-FCG predictor are sensible engineering on top of it, and the ISRD transfer experiment is a good generality check.\n\nI have two main reservations. The first is the decomposition-quality metric. Avg MDQ (Eq. 18) takes, for each query module, the best overlap against any reference module, and it is only averaged over modules that have positive overlap. Modules produced by N2NMatcher average 6.49 functions; ModX averages 1.50. Coarse modules are more likely to touch something, so the Avg MDQ gap in Table II likely overstates boundary-quality improvement. The paper's own Section VII concedes Avg MDQ may favor coarse modules. Because the end-to-end matching metrics in Table III are also computed only on each method's own overlap-eligible queries, the headline module-matching improvement inherits the same granularity confound. The ablation in Table VI, which fixes the decomposition, is cleaner and shows a real but modest gain from the module graph embedding (MRR 0.8137 to 0.8228).\n\nThe second concern is the oracle. Anchor labels, MDQ ground truth, and matching relevance all come from debug-line-based source mapping. The paper acknowledges in Section III-C that under optimization some functions have no verified overlap because debug info is lost. If that loss is correlated with function size or call position, the 42.67% stable-boundary figure and the matching results could both be overestimates. I would want a sensitivity analysis that restricts to high-confidence mappings or uses a second oracle.\n\nThese are addressable. The central argument is not broken; the empirical study stands on its own, and the authors are transparent about the limitations. The paper needs a granularity-invariant decomposition metric or a size-controlled comparison, plus an oracle-sensitivity check, before I would trust the headline \"improves decomposition quality.\" But the idea is novel and the evaluation is substantial.\n\nRecommendation: send to peer review. The referees should ask for the above controls, but this deserves their time. I would cite the empirical finding and probably bring it to the reading group.","headline":"A genuinely new empirical finding about stable boundaries under inlining, but the headline decomposition advantage is partly a granularity artifact; still worth refereeing.","tokens_in":21767,"tokens_out":2869,"would_cite":true,"duration_ms":26875,"reading_group":"yes","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"N2NMatcher learns stable boundary functions in binaries and uses them to keep module matching accurate even when compilers inline code.","keywords":["binary code similarity analysis","function inlining","binary decomposition","module matching","anchor prediction","graph neural networks","call graph analysis","software reuse detection"],"falsifier":"Take a random sample of optimized binaries, manually reconstruct the true source composition of each binary function with a second independent disassembler or hand analysis, and check whether the debug-line-based stable-boundary labels agree; if the labels frequently disagree, or the reported 42.67% stable-boundary rate and the module-matching gaps do not reproduce under corrected labels, the central claim fails.","tokens_in":20694,"feed_emoji":"🧩","tokens_out":7805,"duration_ms":72268,"temperature":0.7,"pith_summary":"Function inlining merges multiple source functions into one binary function and rewires the call graph, which breaks the one-to-one function alignment that binary similarity tools normally rely on. This paper argues that, despite that disruption, binaries still contain caller-side functions that survive as standalone binary functions and never appear purely as inlined callees under any observed compilation setting. On that basis it proposes N2NMatcher, which learns to predict these stable boundaries with a hierarchical graph neural network, cuts the call graph into anchor-bounded modules, and matches those modules with learned graph embeddings rather than function-by-function comparisons. If the argument holds, program-level binary similarity, vulnerability search, and third-party reuse detection become more robust to compiler differences.","feed_headline":"N2NMatcher keeps binary matching accurate when compilers inline code","feed_subtitle":"It predicts the functions that survive inlining and matches modules between them, beating a function-level baseline.","key_machinery":"The load-bearing mechanism is the anchor-bounded module: a connected region of the function call graph cut at predicted anchor functions, where an anchor is a recovered function whose origin source function is stable across compilation variants. Anchors are predicted by a hierarchical ACFG-FCG encoder, which embeds opcode sequences and basic-block control flow inside each function and then propagates calling-context information over the whole function call graph; the predicted anchors plus recovered roots seed a traversal that expands along callee edges and stops at downstream anchors. Module matching then represents each module as a directed call graph whose node features come from a pretrained function embedder, pools it with gated attention, and scores cosine similarity between module embeddings, combined with syntactic and graph-similarity terms. The anchor-bounded traversal is the step that converts the empirical finding about stable boundaries into a decomposition that keeps source regions aligned across compilation variants.","core_discovery":"The central claim is that semantic equivalence across compilation variants survives at the granularity of regions bounded by stable caller-side functions, even though it fails at the granularity of individual binary functions. The paper defines a source-verified stable boundary node as a source function that is recovered as the origin of at least one binary function in some configuration and is never observed inlined under another function's origin in any configuration; in the study's LTO dataset, 42.67% of debug-line-labeled FCG nodes satisfy this condition. N2NMatcher trains an anchor predictor on these labels, decomposes binaries by traversing from predicted anchors and call-graph roots until another anchor blocks the traversal, and compares the resulting modules with graph embeddings learned under source-overlap contrastive supervision. The paper reports that this raises module-level retrieval accuracy over a clustering-based baseline, with top-1 source-function Dice increasing from 0.364 to 0.562 and Recall@1 from 0.487 to 0.782 on its LTO evaluation, and also reports gains on a cross-project reuse corpus.","pith_inferences":["The study's logic suggests a corollary the authors leave implicit: if stable boundaries are as common as reported, anchor-bounded regions could also serve as the natural unit for binary-to-source attribution, giving a coarser alternative to the 1-to-N function matching problem created by inlining.","The ablation shows that FCG propagation alone nearly matches the full model on decomposition quality, which hints that calling-context structure, rather than opcode detail, may be the dominant signal for boundary stability; a cheap caller-side heuristic might reproduce much of the gain.","A direct stress test would be to compile the same projects with LTO disabled or with transformations that break debug-line attribution; the framework's premise predicts graceful degradation as the fraction of recoverable stable boundaries falls, and the rate of that degradation is measurable.","The cross-project drop in absolute accuracy suggests the next bottleneck is not boundary stability but project-specific context in module embeddings, so attention that downweights surrounding project code may matter more than better anchor prediction."],"forward_implications":["Binary similarity tools can stop assuming that individual binary functions correspond one-to-one across compilations and instead compare the regions between stable boundary functions.","Module matching can be performed on stripped binaries using only opcode sequences, control flow, and call-graph context, because training labels come from debug information but inference does not.","Anchor-bounded decomposition produces overlapping modules rather than a strict partition, so the same inlined callee can contribute to more than one module without breaking full FCG coverage.","In the paper's LTO evaluation, the approach improves average source-level module overlap and top-1 module retrieval accuracy relative to clustering-based baselines across cross-compiler and cross-optimization pairs.","The same pipeline, trained on compilation variants, improves cross-project third-party reuse localization relative to a function-level matcher, though absolute accuracy drops when surrounding code differs between projects."],"supporting_citations":[{"why":"Supplies the clustering-based decomposition and module-matching baseline that the proposed approach is compared against end to end.","marker":"[6]"},{"why":"Provides the cross-project reuse corpus and ground-truth reuse relations used for the external validation study.","marker":"[8]"},{"why":"Supplies the community-detection decomposition baseline used in the binary decomposition comparison.","marker":"[14]"},{"why":"Prior empirical study quantifying how function inlining degrades binary similarity analysis, motivating the inlining-resilient design.","marker":"[26]"},{"why":"Provides the prior oracle for binary decomposition under compilation variance that shapes the source-level evaluation methodology.","marker":"[38]"},{"why":"Provides the LTO benchmark dataset from which the study's binaries, compilation variants, and labels are drawn.","marker":"[39]"},{"why":"Supplies the pretrained function embeddings used as node features inside the module graph encoder.","marker":"[46]"}],"fun_headline_variants":["Anchor prediction makes binary module matching inlining-proof","N2NMatcher learns stable function anchors to beat inlining","Inlining-proof module matching via learned stable boundaries","Binary decomposition that survives compiler inlining, then matches"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The load-bearing premise is that debug information and binary-function naming can reliably tell which source function is the origin of a binary function even under O2/O3 optimization; if that oracle is incomplete, the stable-boundary labels and the measured advantage of anchor-bounded matching inherit its errors.","fun_headline_variants_meta":{"raw":{"variants":["Anchor prediction makes binary module matching inlining-proof","N2NMatcher learns stable function anchors to beat inlining","Inlining-proof module matching via learned stable boundaries","Binary decomposition that survives compiler inlining, then matches"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000228,"raw_usage":{"total_tokens":1489,"prompt_tokens":970,"completion_tokens":519,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":586,"completion_tokens_details":{"reasoning_tokens":455}},"tokens_in":586,"tokens_out":519,"duration_ms":5798,"temperature":1.0,"reasoning_tokens":455,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-14T04:15:19.300916+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Take a random sample of optimized binaries, manually reconstruct the true source composition of each binary function with a second independent disassembler or hand analysis, and check whether the debug-line-based stable-boundary labels agree; if the labels frequently disagree, or the reported 42.67% stable-boundary rate and the module-matching gaps do not reproduce under corrected labels, the central claim fails.","supporting_citations":[{"cited_title":"Modx: binary level partially imported third-party library detection via program modularization and semantic matching,","cited_arxiv_id":null,"evidence_quote":"Supplies the clustering-based decomposition and module-matching baseline that the proposed approach is compared against end to end."},{"cited_title":"Searching open- source vulnerability function based on software modularization,","cited_arxiv_id":null,"evidence_quote":"Supplies the community-detection decomposition baseline used in the binary decomposition comparison."},{"cited_title":"Towards an oracle for binary decomposition under compilation vari- ance,","cited_arxiv_id":null,"evidence_quote":"Provides the prior oracle for binary decomposition under compilation variance that shapes the source-level evaluation methodology."},{"cited_title":"Revisiting binary code similarity analysis using interpretable feature engineering and lessons learned,","cited_arxiv_id":null,"evidence_quote":"Provides the LTO benchmark dataset from which the study's binaries, compilation variants, and labels are drawn."},{"cited_title":"Neural network- based graph embedding for cross-platform binary code similarity detec- tion,","cited_arxiv_id":null,"evidence_quote":"Supplies the pretrained function embeddings used as node features inside the module graph encoder."}],"review_version":1}