Pith. sign in

REVIEW 3 major objections 5 minor 76 references

Instruction Alignment for Binary Code Representation Learning

T0 review · 3 major / 5 minor · reviewed 2026-08-16 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read The paper claims that adding instruction-level alignment supervision, derived from compiler debug information, to function-level contrastive training improves binary code similarity retrieval and makes the model's similarity judgments…

desk verdict Instruction alignment via debug info is a genuinely new and well-designed idea, but the main retrieval gain needs error bars before I'd believe it. read the letter →

arxiv 2608.11766 v1 pith:IF4E4SYG submitted 2026-08-12 cs.SE cs.AIcs.CR

Huaijin Wang , Shuai Wang This is my paper · ORCID
classification cs.SEcs.AIcs.CR
keywords binarycoderepresentationlearningsimilarityanalysisinstructionalignmentcontrastivedebuginformationInfoNCEinterpretableembeddingsretrieval
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper sets out to show that fine-grained instruction-level correspondences between binary functions carry a supervision signal that function-level binary code similarity models currently ignore. Using compiler debug information, two assembly instructions that trace to the same source line are treated as aligned, and the paper introduces InsnAlign, which adds an InfoNCE-style alignment loss on these correspondences to standard function-level contrastive training. The main empirical claim is that this auxiliary objective improves function-level retrieval accuracy across all 16 cross-compiler, cross-optimization settings tested, and that the resulting per-instruction alignments are more discriminative than the function embedding alone when hard negatives are compared. The paper also argues that instruction alignment makes similarity judgments interpretable, since the aligned instruction pairs serve as visible evidence for a decision. The broader point a sympathetic reader takes away is that debug information is an underused source of fine-grained labels for binary representation learning.

What carries the argument

The central mechanism is the instruction alignment matrix $\mathbf{M}$, built from compiler debug information: $\mathbf{M}_{ij}=1$ when instruction $i$ in one binary and instruction $j$ in the paired binary originate from the same source line. Instruction-level embeddings are obtained by mean-pooling the transformer's token hidden states over the tokens that belong to each instruction, and a cosine-similarity matrix $\mathbf{S}$ is computed between all instruction pairs of the two functions. The alignment objective is a symmetric, multi-positive InfoNCE loss that, for each query instruction with at least one aligned counterpart, maximizes the aggregate softmax probability over its positive matches among the paired function's instructions. This loss is added to the function-level triplet loss with a small weight $\lambda$, chosen so that the already-converged function-level objective stays stable while the alignment signal is learned.

What would settle it

Retrain InsnAlign with debug labels systematically shifted one source line up or down, so every instruction is paired with a semantically unrelated counterpart while the training procedure is otherwise unchanged; if function-level Recall@1 still rises, the improvement is not caused by true instruction alignment.

Watch

Extended reading notes

Core claim

The paper's central claim is that explicitly supervising instruction-level alignment improves the quality of function-level binary code embeddings. On the BinKit evaluation set, starting from already-finetuned jTrans and CLAP checkpoints and continuing training with the auxiliary alignment loss, InsnAlign reports higher function-level Recall@1 than the baselines in every one of the 16 compiler-optimization settings, with average gains from 0.4011 to 0.4282 for the jTrans-based model and from 0.6396 to 0.6590 for the CLAP-based model. The instruction-level signal is also more discriminative on hard negative pairs: the mean alignment score achieves a larger Cohen's d than function cosine similarity under top-5 negative sampling for both backbones. Combining the two scores in a synergy re-ranking step further improves retrieval, by 27.9% for the jTrans-based model. The paper presents this as evidence that instruction alignment is both a practical training signal and an interpretability mechanism for binary similarity decisions.

Load-bearing premise

The method depends on compiler debug information mapping each assembly instruction to the correct source line; if aggressive optimization systematically misattributes instructions to the wrong lines, the alignment loss trains on wrong pairings and the reported function-level gains would not follow.

Editorial extensions

If this is right

  • Function-level binary similarity models can be improved with labels already present in the compilation pipeline, without collecting new function-level ground truth.
  • The instruction-level alignments give analysts inspectable evidence for why two functions are judged similar, which could be surfaced in reverse engineering and malware-analysis tools.
  • Because the gains hold across old and new compilers and across optimization levels, the benefit is not tied to a single toolchain's debug format.
  • The synergy between the mean alignment score and function embedding similarity suggests that fine-grained and coarse-grained signals are complementary and can be combined by re-ranking.
  • Alignment supervision remains effective when function-level training uses hard negative mining, so it adds value on top of stronger contrastive baselines.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • If compiler debug line mappings are widely available, instruction alignment could become a drop-in auxiliary objective for any token-level binary embedding model, not only the two transformers evaluated here.
  • The patch-presence-detection case suggests a concrete research direction: align a query binary against both vulnerable and patched variants and use the absence of matches on the patch's source lines as the decision signal; the paper only sketches this possibility.
  • A systematic label-noise audit, shifting source lines rather than corrupting them randomly, would be the natural stress test of whether the alignment objective is learning semantics or just matching debug metadata.
  • The failure taxonomy identifies thin wrappers, truncated contexts, and near-twin functions as the residual error classes, implying that instruction alignment will help most on functions with rich bodies and visible callee semantics.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

3 major / 5 minor

Summary. The paper proposes InsnAlign, a training method that augments function-level contrastive learning for binary code embeddings with an auxiliary instruction-level alignment loss. The alignment supervision is derived from compiler debug information: assembly instructions from different compilations of the same source function are treated as aligned when they map to the same source line. The authors first show that function-level fine-tuning already improves instruction alignment in a preliminary study, then train jTrans and CLAP with the auxiliary loss on a debug-enabled subset of BinaryCorp and evaluate on BinKit. The evaluation covers instruction alignment quality, function-level Recall@1 across 16 cross-compiler/cross-optimization settings, discriminability of a mean alignment score, label-noise resilience, synergy re-ranking, and qualitative failure-mode and patch-presence case studies.

Significance. If the central transfer result holds, this is a useful contribution: it identifies a previously underused fine-grained supervision signal for binary code representation learning and provides an interpretable, instruction-level evidence mechanism for similarity judgments. The controlled comparison is well designed: for each base model, the λ=0 continuation and the λ>0 InsnAlign variant share dataset, tokenization, and training settings, and evaluation is performed on BinKit projects disjoint from the BinaryCorp training set. The paper also includes strengths that are easy to underweight: released code and data, a manual audit of label correctness, a quantitative analysis of failure modes, and a concrete patch-presence case study. However, the central RQ2 claim is not yet statistically established because Table 2 reports point estimates without variance, confidence intervals, or significance tests, and the only significance test in the paper concerns the synergy re-ranking mechanism, not the main λ=0 versus λ>0 comparison.

major comments (3)
  1. [§5.2, Table 2] The central claim of RQ2 — that instruction alignment training improves function-level Recall@1 — is currently supported only by single point estimates. Table 2 reports no variance, confidence intervals, or significance tests for any of the 16 settings. For CLAP, the average gain is 0.0194 (0.6396 vs. 0.6590) and individual gains are between roughly +0.015 and +0.023; these differences are small enough that run-to-run noise is a plausible alternative explanation. Since RQ3 (Table 3) reports averages over seeds 3, 5, 7, and 42, the same repeated-seed protocol should be applied to the RQ2 comparison, or the authors must justify its absence. I request repeated-seed results and a paired significance test (e.g., bootstrap over query functions) for the λ=0 vs. λ>0 comparison.
  2. [§5.2.2, §5.5] The 16 settings in Table 2 are not independent replicates: they share query sets, candidate pools, and the same underlying model weights, so the statement that improvement holds 'consistently across all 16 settings' cannot substitute for a statistical test. A sign test or unanimous-vote argument over these cells would ignore the dependence structure. The only significance test in the paper, the paired t-test in §5.5 (t=27.0, p=5.2×10^{-161}), applies to the synergy re-ranking gain, not to the central InsnAlign-vs-λ=0 comparison. Consequently the main transfer claim currently lacks inferential support even though the evaluation design is otherwise carefully controlled.
  3. [§5.4] The noise-resilience experiment corrupts instruction-to-source-line labels randomly, but the failure mode most relevant to the proposed training signal is systematic misattribution under aggressive optimization (e.g., folded lines, inlined callees absorbing line attributions). The manual audit provides useful evidence that only 2.8% of mappings are suspicious or wrong and 5.3% are plausible, but it is based on 100 sampled functions and the sample-selection procedure is not described. The paper should either specify the audit sampling and its coverage of the O3 configurations where misattribution is most likely, or add a structured-corruption experiment; otherwise the transfer result rests on label correctness that has been only partially stress-tested.
minor comments (5)
  1. [§4.6] The statement 'All binaries are stripped before extracting assembly instructions' is ambiguous in light of the heavy reliance on debug information for label construction; please clarify whether stripping removes only the symbol table or also DWARF sections, and whether the debug info used for labels comes from unstripped copies of the same binaries.
  2. [§4.2, Eq. (8)] The glyphs '˝' and '∑' appear corrupted in the equation and the surrounding definitions; the notation should be typeset with standard sum symbols and explicit index sets.
  3. [Table 4 footnote] The footnote marker on 'Average improvement1' is not matched to an actual footnote; ensure the marker aligns with the explanation below the table.
  4. [§5.2.2] The sentence 'jTrans performs much better on GCC-11 compilers, indicating the training data used in this study was compiled with GCC' is an unsupported inference from the table; either provide a training-data compiler breakdown or rephrase it as a conjecture.
  5. [§5.6, Cause 1] The 'invisible callee semantics' example would benefit from an explicit note that symbols such as 'xcharalloc' and 'xmalloc' come from debug information rather than from the stripped binaries, to avoid confusion about how the ground truth was obtained.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the central claim is evaluated on held-out BinKit and does not reduce to its training inputs.

full rationale

InsnAlign's derivation is self-contained and externally benchmarked. The instruction alignment loss (Eqs. 7-9) is defined from DWARF source-line mappings and added to the existing triplet objective (Eq. 10); this is a genuine auxiliary training signal, not a renamed fit. RQ1 measures alignment on BinKit, which the paper states is disjoint from BinaryCorp training; observing that the trained objective improves on its own metric is standard supervised evaluation, not circular prediction. The central transfer claim (RQ2, Table 2) is function-level Recall@1 on held-out BinKit projects, with lambda=0 baselines retrained on the same data and settings, so the comparison isolates the alignment term rather than reducing to it. RQ3's MAS discriminability and RQ5's synergy re-ranking are additional empirical evaluations derived from the same instruction embeddings; they do not assume the conclusion they test. Self-citations (vSim for deduplication, jTrans/CLAP checkpoints) are procedural provenance; no uniqueness theorem or ansatz is imported from the authors' prior work. The paper even contains explicit limitation analyses (RQ4 noise, case-study failure causes) that make the empirical claims falsifiable. No equation-level identity between inputs and outputs was found, so there is no circularity.

Assumptions & free parameters 5 free parameters · 4 assumptions · 0 invented entities

The paper introduces no invented entities. The central claim rests on the reliability of compiler debug labels as an external assumption and on a handful of hyperparameters chosen empirically; no parameter is fitted to the main test-set metric.

free parameters (5)
  • alignment loss weight λ = 0.001 (0.02 for hard negatives)
    Chosen empirically in preliminary experiments on the validation set to balance the much larger alignment loss against the near-zero triplet loss; the paper notes this balance is necessary.
  • synergy weight γ = 0.5
    Set to 0.5 to combine cosine and MAS in Eq.14; no sensitivity analysis reported.
  • InfoNCE temperature τ = Not reported
    Required in Eq.8, but implementation details omit its value; likely inherited from the base model.
  • triplet margin α = Not reported
    Required in Eq.1 and consistent with jTrans, but not stated in this paper.
  • frozen layer count L = 10
    Consistent with original jTrans finetuning; part of the architecture, not a central fitted parameter but a design choice.
assumptions (4)
  • domain assumption DWARF debug info accurately maps each assembly instruction to the source line that produced it.
    Established in §2.4 and used to construct the match matrix M; RQ4 audits correctness but cannot guarantee completeness.
  • domain assumption Two instructions mapping to the same source line are semantically aligned and can serve as positive training pairs.
    Central equivalence underlying Eq.8 and the training pairs in §4.4; if source-line identity does not imply semantic correspondence, the auxiliary loss is mis-specified.
  • domain assumption Mean-pooling token hidden states yields valid instruction embeddings.
    Eq.2 in §3.1; no learnable parameters, so alignment quality depends on the backbone's token representations being informative at instruction granularity.
  • standard math InfoNCE and supervised contrastive learning are valid objectives for representation learning.
    Cites [43] and [25]; standard background.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Instruction Alignment for Binary Code Representation Learning." pith.science (2026). https://pith.science/paper/IF4E4SYG

@misc{pith2026260811766,
  author       = {Pith},
  title        = {Pith review of: Instruction Alignment for Binary Code Representation Learning},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/IF4E4SYG}},
  note         = {Machine review of arXiv:2608.11766}
}
read the original abstract

Binary code representation learning is a fundamental problem in software security and reverse engineering. Existing methods mainly learn function-level embeddings that capture coarse-grained semantic relationships between binary functions, but they largely ignore fine-grained instruction-level correspondences. This limitation misses valuable supervision signals available from compiler debug information, which can support the learning of more accurate and interpretable binary code representations. We propose to leverage instruction alignment knowledge to further improve binary code representation learning. Our preliminary study reveals that models finetuned for function-level binary code similarity exhibit substantially better instruction alignment than their pre-trained model, suggesting a strong correlation between instruction alignment and function-level embedding quality. Motivated by this observation, we design a training approach that explicitly incorporates instruction alignment as an auxiliary training objective. Our experiments show that instruction alignment training improves retrieval accuracy and provides more discriminative signal for the model's similarity judgments.

Figures

Figures reproduced from arXiv: 2608.11766 by the authors.

Figure 1
Figure 1. Ground truth construction and training objective. [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. Debug information provides a mapping from assembly instructions to source lines. (b) and (c) are compiled from the [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗
Figure 3
Figure 3. Instruction alignment overview. Colored M𝑖,𝑗 de￾notes instruction 𝑎𝑖 and 𝑏𝑗 originates from the same source line. Deep gray S𝑖,𝑗 denotes cos(e 𝐴 𝑖 , e 𝐵 𝑗 ) is close to 1. Why InfoNCE? Unlike function-level BCSA, where negatives can be drawn from the entire dataset (e.g., millions of candidate func￾tions), instruction alignment operates within a single function pair: for a query instruction 𝑎𝑖 , the candidate set is… view at source ↗
Figures from the paper (7 more)
Figure 4
Figure 4. Figure 4: Training loss curves. (a) Instruction alignment loss [PITH_FULL_IMAGE:figures/full_fig_p007_4.png]
Figure 5
Figure 5. Figure 5: Average Recallinsn@1 and MRRinsn . Moreover, we present case studies (§5.6) to understand InsnAlign’s difficult situations and show the potential for patch presence detec￾tion, a challenging application for function-level representations. 5.1 RQ1: Training Loss Converg…
Figure 6
Figure 6. Figure 6: Example of a PLAUSIBLE label. Lines 2, 4, and 5 are absorbed into the common return sequence on the right; thus, the mov instruction can be attributed to both lines 2 and 4, although the assembly is labeled only with line 2. attribute instructions to coarse or imprecis…
Figure 7
Figure 7. Figure 7: Simplified assembly functions of blake2b. The line numbers denote their corresponding source lines. (a) gcc -O0 (b) gcc –O3 → ↓ Inlined callee (1) Without ground truth. (2) With ground truth. ↓ [PITH_FULL_IMAGE:figures/full_fig_p010_7.png]
Figure 8
Figure 8. Figure 8: Instruction alignment similarity heatmap of Fig. [PITH_FULL_IMAGE:figures/full_fig_p010_8.png]
Figure 10
Figure 10. Figure 10: The code snippet of vulnerable function line_bytes_split. Vulnerable Patched → ↓ Vulnerable Vulnerable → ↓ Correctly aligned instructions [PITH_FULL_IMAGE:figures/full_fig_p011_10.png]
Figure 11
Figure 11. Figure 11: Instruction alignment similarity heatmap for [PITH_FULL_IMAGE:figures/full_fig_p011_11.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

76 extracted references · 33 canonical work pages

  1. [1]

    Tal Ben-Nun, Alice Shoshana Jakobovits, and Torsten Hoefler. 2018. Neu- ral Code Comprehension: A Learnable Representation of Code Semantics. In Advances in Neural Information Processing Systems, S. Bengio, H. Wallach, H. Larochelle, K. Grauman, N. Cesa-Bianchi, and R. Garnett (Eds.), Vol. 31. Cur- ran Associates, Inc. https://proceedings.neurips.cc/paper...

    work page 2018

  2. [2]

    Andrew P. Bradley. 1997. The use of the area under the ROC curve in the evaluation of machine learning algorithms.Pattern Recognition30, 7 (1997), 1145–1159. doi:10.1016/S0031-3203(96)00142-2

    doi:10.1016/s0031-3203(96)00142-2 1997

  3. [3]

    Mahinthan Chandramohan, Yinxing Xue, Zhengzi Xu, Yang Liu, Chia Yuan Cho, and Hee Beng Kuan Tan. 2016. BinGo: cross-architecture cross-OS binary search. InProceedings of the 2016 24th ACM SIGSOFT International Symposium on Foundations of Software Engineering(Seattle, WA, USA)(FSE 2016). Association for Computing Machinery, New York, NY, USA, 678–689. doi:...

    doi:10.1145/2950290 2016

  4. [4]

    Zhao Chen, Vijay Badrinarayanan, Chen-Yu Lee, and Andrew Rabinovich. 2018. GradNorm: Gradient Normalization for Adaptive Loss Balancing in Deep Mul- titask Networks. InProceedings of the 35th International Conference on Machine Learning (Proceedings of Machine Learning Research, Vol. 80), Jennifer Dy and An- dreas Krause (Eds.). PMLR, 794–803. https://pro...

    work page 2018

  5. [5]

    2013.Statistical power analysis for the behavioral sciences

    Jacob Cohen. 2013.Statistical power analysis for the behavioral sciences. routledge. doi:10.4324/9780203771587

    doi:10.4324/9780203771587 2013

  6. [6]

    Yaniv David, Nimrod Partush, and Eran Yahav. 2017. Similarity of binaries through re-optimization. InProceedings of the 38th ACM SIGPLAN Conference on Programming Language Design and Implementation(Barcelona, Spain)(PLDI 2017). New York, NY, USA, 79–94. doi:10.1145/3062341.3062387 Instruction Alignment for Binary Code Representation Learning ASE ’26, Octo...

    arXiv 2017

  7. [7]

    Yaniv David and Eran Yahav. 2014. Tracelet-based code search in executables. InProceedings of the 35th ACM SIGPLAN Conference on Programming Language Design and Implementation(Edinburgh, United Kingdom)(PLDI ’14). New York, NY, USA, 349–360. doi:10.1145/2594291.2594343

    arXiv 2014

  8. [8]

    Jacob Devlin. 2018. BERT: Pre-training of deep bidirectional transformers for language understanding.arXiv preprint arXiv:1810.04805(2018)

    arXiv 2018

Show all 76 references
  1. [9]

    Steven HH Ding, Benjamin CM Fung, and Philippe Charland. 2019. Asm2vec: Boosting static representation robustness for binary clone search against code obfuscation and compiler optimization. In2019 ieee symposium on security and privacy. IEEE, 472–489. doi:10.1109/SP.2019.00003

    2019

  2. [10]

    Yue Duan, Xuezixiang Li, Jinghan Wang, and Heng Yin. 2020. DeepBinDiff: Learning Program-Wide Code Representations for Binary Diffing. InNetwork and Distributed Systems Security (NDSS) Symposium. doi:10.14722/ndss.2020.24311

    2020

  3. [11]

    2017.DW ARF Debugging Information Format

    DWARF Debugging Information Format Committee. 2017.DW ARF Debugging Information Format. https://dwarfstd.org/doc/DWARF5.pdf

    2017

  4. [12]

    Manuel Egele, Maverick Woo, Peter Chapman, and David Brumley. 2014. Blanket Execution: Dynamic Similarity Testing for Program Binaries and Components. InProceedings of the 23rd USENIX Security Symposium. USENIX Association, 303–317

    2014

  5. [13]

    2026.Coreutils fix for CVE-2024-0684.https://github.com/coreutils/ coreutils/commit/c4c5ed8f4e9cd55a12966d4f520e3a13101637d9

    Paul Eggert. 2026.Coreutils fix for CVE-2024-0684.https://github.com/coreutils/ coreutils/commit/c4c5ed8f4e9cd55a12966d4f520e3a13101637d9

    2026

  6. [14]

    Qian Feng, Rundong Zhou, Chengcheng Xu, Yao Cheng, Brian Testa, and Heng Yin. 2016. Scalable Graph-based Bug Search for Firmware Images. InProceedings of the 2016 ACM SIGSAC Conference on Computer and Communications Security (CCS ’16). 480–491. doi:10.1145/2976749.2978370

    2016

  7. [15]

    David J Hand and Christoforos Anagnostopoulos. 2023. Notes on the H-measure of classifier performance.Advances in Data Analysis and Classification17, 1 (2023), 109–124. doi:10.1007/s11634-021-00490-3

    2023 doi

  8. [16]

    Irfan Ul Haq and Juan Caballero. 2021. A Survey of Binary Code Similarity.ACM Comput. Surv.54, 3, Article 51 (April 2021), 38 pages. doi:10.1145/3446371

    2021 doi

  9. [17]

    Haojie He, Xingwei Lin, Ziang Weng, Ruijie Zhao, Shuitao Gan, Libo Chen, Yuede Ji, Jiashui Wang, and Zhi Xue. 2024. Code is not natural language: Unlock the power of semantics-oriented graph representation for binary code similarity detection. In33rd USENIX Security Symposium ...

    2024

  10. [18]

    2022.{RapidPatch}: firmware hotpatching for{Real-Time} embedded devices

    Yi He, Zhenhua Zou, Kun Sun, Zhuotao Liu, Ke Xu, Qian Wang, Chao Shen, Zhi Wang, and Qi Li. 2022.{RapidPatch}: firmware hotpatching for{Real-Time} embedded devices. In31st USENIX Security Symposium (USENIX Security 22). 2225–2242

    2022

  11. [19]

    SA Hex-Rays. 2026. IDA Pro: Powerful Disassembler, Decompiler & Debugger. https://hex-rays.com/ida-pro

    2026

  12. [20]

    Ang Jia, Ming Fan, Wuxia Jin, Xi Xu, Zhaohui Zhou, Qiyi Tang, Sen Nie, Shi Wu, and Ting Liu. 2023. 1-to-1 or 1-to-n? Investigating the Effect of Function Inlining on Binary Similarity Analysis.ACM Transactions on Software Engineering and Methodology32, 4 (2023), 1–26

    2023

  13. [21]

    Ang Jia, Ming Fan, Xi Xu, Wuxia Jin, Haijun Wang, and Ting Liu. 2024. Cross- inlining binary function similarity detection. InProceedings of the IEEE/ACM 46th International Conference on Software Engineering. 1–13

    2024

  14. [22]

    Ling Jiang, Junwen An, Huihui Huang, Qiyi Tang, Sen Nie, Shi Wu, and Yuqun Zhang. 2024. BinaryAI: Binary Software Composition Analysis via Intelligent Binary Source Code Matching. InProceedings of the IEEE/ACM 46th International Conference on Software Engineering (ICSE ’24). A...

    2024

  15. [23]

    Linxi Jiang, Xin Jin, and Zhiqiang Lin. 2025. Beyond Classification: Inferring Function Names in Stripped Binaries via Domain Adapted LLMs. InNetwork and Distributed System Security (NDSS) Symposium. doi:10.14722/ndss.2025.240797

    2025

  16. [24]

    Nan Jiang, Chengxiao Wang, Kevin Liu, Xiangzhe Xu, Lin Tan, Xiangyu Zhang, and Petr Babkin. 2025. Nova: Generative Language Models for Assembly Code with Hierarchical Attention and Contrastive Learning. InInternational Conference on Learning Representations. 95905–95926. https...

    2025

  17. [25]

    Prannay Khosla, Piotr Teterwak, Chen Wang, Aaron Sarna, Yonglong Tian, Phillip Isola, Aaron Maschinot, Ce Liu, and Dilip Krishnan. 2020. Supervised Contrastive Learning. (2020), 18661–18673. https://proceedings.neurips.cc/paper_files/paper/ 2020/file/d89a66c7c80a29b1bdbab0f2a1...

    2020

  18. [26]

    Dongkwan Kim, Eunsoo Kim, Sang Kil Cha, Sooel Son, and Yongdae Kim. 2023. Revisiting Binary Code Similarity Analysis Using Interpretable Feature Engineer- ing and Lessons Learned.IEEE Transactions on Software Engineering49, 4 (2023), 1661–1682. doi:10.1109/TSE.2022.3187689

    2023

  19. [27]

    Quoc Le and Tomas Mikolov. 2014. Distributed representations of sentences and documents. InProceedings of the 31st International Conference on International Conference on Machine Learning - Volume 32(Beijing, China)(ICML’14). JMLR.org, II–1188–II–1196

    2014

  20. [28]

    Xuezixiang Li, Yu Qu, and Heng Yin. 2021. Palmtree: learning an assembly language model for instruction embedding. InProceedings of the 2021 ACM SIGSAC Conference on Computer and Communications Security. 3236–3251. doi:10.1145/ 3460120.3484587

    2021

  21. [29]

    Zongjie Li, Pingchuan Ma, Huaijin Wang, Shuai Wang, Qiyi Tang, Sen Nie, and Shi Wu. 2022. Unleashing the power of compiler intermediate representation to enhance neural program embeddings. InProceedings of the 44th International Conference on Software Engineering. 2253–2265. d...

    2022

  22. [30]

    Yiming Liu, Ruofan Liu, Yun Lin, Zicong Zhang, Weiyu Kong, Pengnian Qi, Xiao Cheng, Weinan Zhang, Qianxiang Wang, and Linpeng Huang. 2026. XSearch: Ex- plainable Code Search via Concept-to-Code Alignment. arXiv:2605.16046 [cs.SE] https://arxiv.org/abs/2605.16046

    2026 arXiv

  23. [31]

    Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. 2019. Roberta: A robustly optimized bert pretraining approach.arXiv preprint arXiv:1907.11692 (2019)

    2019 arXiv

  24. [32]

    Zhijie Liu, Qiyi Tang, Sen Nie, Shi Wu, Liang Feng Zhang, and Yutian Tang. 2025. KEENHash: Hashing programs into function-aware embeddings for large-scale binary code similarity analysis.Proceedings of the ACM on Software Engineering 2, ISSTA (2025), 801–824. doi:10.1145/3728911

    2025 doi

  25. [33]

    Zhibo Liu, Huaijin Wang, Wai Kin Wong, Daoyuan Wu, and Shuai Wang. 2026. No More Translation at Runtime: LLM-Empowered Static Binary Translation. InProceedings of the 21st European Conference on Computer Systems(McE- wan Hall/The University of Edinburgh, Edinburgh, Scotland UK...

    2026

  26. [34]

    Zhibo Liu, Yuanyuan Yuan, Shuai Wang, and Yuyan Bao. 2022. SoK: Demysti- fying binary lifters through the lens of downstream applications. In2022 IEEE Symposium on Security and Privacy (SP). IEEE, 1100–1119. doi:10.1109/SP46214. 2022.9833799

    2022

  27. [35]

    Hongyi Lu, Zhibo Liu, Shuai Wang, and Fengwei Zhang. 2024. Dtd: Compre- hensive and scalable testing for debuggers.Proceedings of the ACM on Software Engineering1, FSE (2024), 1172–1193. doi:10.1145/3643779

    2024 doi

  28. [36]

    Lannan Luo, Jiang Ming, Dinghao Wu, Peng Liu, and Sencun Zhu. 2014. Semantics-based obfuscation-resilient binary code similarity comparison with applications to software plagiarism detection. InProceedings of the 22nd ACM SIGSOFT international symposium on foundations of softw...

    2014

  29. [37]

    Lannan Luo, Jiang Ming, Dinghao Wu, Peng Liu, and Sencun Zhu. 2017. Semantics-based obfuscation-resilient binary code similarity comparison with applications to software and algorithm plagiarism detection.IEEE Transactions on Software Engineering43, 12 (2017), 1157–1177. doi:1...

    2017

  30. [38]

    Zhenhao Luo, Pengfei Wang, Baosheng Wang, Yong Tang, Wei Xie, Xu Zhou, Danjun Liu, and Kai Lu. 2023. VulHawk: Cross-architecture Vulnerability Detec- tion with Entropy-based Binary Code Search.. InNetwork and Distributed Systems Security (NDSS) Symposium. doi:10.14722/ndss.2023.24415

    2023

  31. [39]

    Andrea Marcelli, Mariano Graziano, Xabier Ugarte-Pedrero, Yanick Fratantonio, Mohamad Mansouri, and Davide Balzarotti. 2022. How machine learning is solv- ing the binary function similarity problem. In31st USENIX Security Symposium (USENIX Security 22). 2099–2116

    2022

  32. [40]

    Luca Massarelli, Giuseppe Antonio Di Luna, Fabio Petroni, Roberto Baldoni, and Leonardo Querzoni. 2019. SAFE: Self-attentive function embeddings for binary similarity. InInternational Conference on Detection of Intrusions and Malware, and Vulnerability Assessment. Springer, 30...

    2019 doi

  33. [41]

    Tomáš Mikolov, Martin Karafiát, Lukáš Burget, Jan Černock`y, and Sanjeev Khu- danpur. 2010. Recurrent neural network based language model. InEleventh annual conference of the international speech communication association

    2010

  34. [42]

    Jiang Ming, Dongpeng Xu, Yufei Jiang, and Dinghao Wu. 2017. Binsim: Trace- based semantic binary diffing via system call sliced segment equivalence checking. InProceedings of the 26th USENIX Security Symposium

    2017

  35. [43]

    Aaron van den Oord, Yazhe Li, and Oriol Vinyals. 2018. Representation learning with contrastive predictive coding.arXiv preprint arXiv:1807.03748(2018)

    2018 arXiv

  36. [44]

    Kexin Pei, Zhou Xuan, Junfeng Yang, Suman Jana, and Baishakhi Ray. 2023. Learning Approximate Execution Semantics From Traces for Binary Function Similarity.IEEE Transactions on Software Engineering49, 4 (2023), 2776–2790. doi:10.1109/TSE.2022.3231621

    2023

  37. [45]

    Hu Peiwei, Liang Ruigang, and Chen Kai. 2024. DeGPT: Optimizing Decompiler Output with LLM. InNDSS. doi:10.14722/ndss.2024.24401

    2024

  38. [46]

    Joshua Robinson, Ching-Yao Chuang, Suvrit Sra, and Stefanie Jegelka. 2021. Contrastive Learning with Hard Negative Samples. arXiv:2010.04592 [cs.LG] https://arxiv.org/abs/2010.04592

    2021 arXiv

  39. [47]

    Takaya Saito and Marc Rehmsmeier. 2015. The precision-recall plot is more informative than the ROC plot when evaluating binary classifiers on imbalanced datasets.PloS one10, 3 (2015), e0118432

    2015

  40. [48]

    Florian Schroff, Dmitry Kalenichenko, and James Philbin. 2015. Facenet: A unified embedding for face recognition and clustering. InProceedings of the IEEE conference on computer vision and pattern recognition. 815–823. doi:10.1109/CVPR. 2015.7298682

    2015

  41. [49]

    Xiuwei Shang, Guoqiang Chen, Shaoyin Cheng, Benlong Wu, Li Hu, Gangyang Li, Weiming Zhang, and Nenghai Yu. 2025. BinMetric: a comprehensive binary code analysis benchmark for large language models. InProceedings of the Thirty-Fourth International Joint Conference on Artificial...

    2025 doi

  42. [50]

    Xiuwei Shang, Shaoyin Cheng, Guoqiang Chen, Yanming Zhang, Li Hu, Xiao Yu, Gangyang Li, Weiming Zhang, and Nenghai Yu. 2024. How Far Have We Gone in Binary Code Understanding Using Large Language Models . In2024 IEEE International Conference on Software Maintenance and Evoluti...

    2024

  43. [51]

    Hanzhuo Tan, Qi Luo, Jing Li, and Yuqun Zhang. 2024. LLM4Decompile: Decom- piling Binary Code with Large Language Models. InProceedings of the 2024 Con- ference on Empirical Methods in Natural Language Processing, Yaser Al-Onaizan, Mohit Bansal, and Yun-Nung Chen (Eds.). Assoc...

    2024 doi

  44. [52]

    Wong Wai Kin, Wu Daoyuan, Liu Zhibo, Wang Huaijin, Li Zongjie, and Wang Shuai. 2026. BinRAG: An RAG-Based Decompilation Framework Fusing Name Prediction and Calling Context. InProceedings of the 2026 International Symposium on Software Testing and Analysis (ISSTA ’26). doi:10....

    2026 doi

  45. [54]

    Hao Wang, Zeyu Gao, Chao Zhang, Mingyang Sun, Yuchen Zhou, Han Qiu, and Xi Xiao. 2024. CEBin: A Cost-Effective Framework for Large-Scale Binary Code Similarity Detection. InProceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA). 14...

    2024

  46. [55]

    Huaijin Wang and Zhiqiang Lin. 2026. vSim: Semantics-aware value extraction for efficient binary code similarity analysis. InNetwork and Distributed Systems Security (NDSS) Symposium. doi:10.14722/ndss.2026.240213

    2026

  47. [56]

    Huaijin Wang, Zhibo Liu, Yanbo Dai, Shuai Wang, Qiyi Tang, Sen Nie, and Shi Wu. 2025. Preserving Privacy in Software Composition Analysis: A Study of Technical Solutions and Enhancements. InProceedings of the IEEE/ACM 47th International Conference on Software Engineering (ICSE...

    2025

  48. [57]

    Huaijin Wang, Zhibo Liu, Shuai Wang, Ying Wang, Qiyi Tang, Sen Nie, and Shi Wu. 2024. Are We There Yet? Filling the Gap Between Binary Similarity Analysis and Binary Software Composition Analysis. In2024 IEEE 9th European Symposium on Security and Privacy. 506–523. doi:10.1109...

    2024

  49. [58]

    Huaijin Wang, Pingchuan Ma, Shuai Wang, Qiyi Tang, Sen Nie, and Shi Wu. 2023. sem2vec: Semantics-aware Assembly Tracelet Embedding.ACM Transactions on Software Engineering and Methodology32, 4, Article 90 (May 2023), 34 pages. doi:10.1145/3569933

    2023 doi

  50. [59]

    Huaijin Wang, Pingchuan Ma, Yuanyuan Yuan, Zhibo Liu, Shuai Wang, Qiyi Tang, Sen Nie, and Shi Wu. 2022. Enhancing DNN-based binary code function search with low-cost equivalence checking.IEEE Transactions on Software Engineering 49, 1 (2022), 226–250. doi:10.1109/TSE.2022.3149240

    2022

  51. [60]

    Hao Wang, Wenjie Qu, Gilad Katz, Wenyu Zhu, Zeyu Gao, Han Qiu, Jianwei Zhuge, and Chao Zhang. 2022. jTrans: jump-aware transformer for binary code similarity detection. InProceedings of the 31st ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA). 1–13...

    2022 doi

  52. [61]

    Huaijin Wang, Shuai Wang, Dongpeng Xu, Xiangyu Zhang, and Xiao Liu. 2022. Generating Effective Software Obfuscation Sequences With Reinforcement Learn- ing.IEEE Transactions on Dependable and Secure Computing19, 3 (2022), 1900–

    2022

  53. [62]

    Shuai Wang and Dinghao Wu. 2017. In-memory fuzzing for binary code similarity analysis. In2017 32nd IEEE/ACM International Conference on Automated Software Engineering (ASE). 319–330. doi:10.5555/3155562.3155606

    2017

  54. [63]

    Wai Kin Wong, Huaijin Wang, Zongjie Li, Zhibo Liu, Shuai Wang, Qiyi Tang, Sen Nie, and Shi Wu. 2023. Refining decompiled c code with large language models. arXiv preprint arXiv:2310.06530(2023)

    2023 arXiv

  55. [64]

    Wai Kin Wong, Huaijin Wang, Zongjie Li, and Shuai Wang. 2024. BinAug: Enhanc- ing Binary Similarity Analysis with Low-Cost Input Repairing. InProceedings of the 46th IEEE/ACM International Conference on Software Engineering(Lisbon, Portugal). Article 7, 13 pages. doi:10.1145/3...

    2024

  56. [65]

    Wai Kin Wong, Huaijin Wang, Pingchuan Ma, Shuai Wang, Mingyue Jiang, Tsong Yueh Chen, Qiyi Tang, Sen Nie, and Shi Wu. 2022. Deceiving Deep Neural Networks-Based Binary Code Matching with Adversarial Programs. In2022 IEEE International Conference on Software Maintenance and Evo...

    2022

  57. [66]

    Wai Kin Wong, Daoyuan Wu, Huaijin Wang, Zongjie Li, Zhibo Liu, Shuai Wang, Qiyi Tang, Sen Nie, and Shi Wu. 2025. DecLLM: LLM-Augmented Recompilable Decompilation for Enabling Programmatic Use of Decompiled Code.Proc. ACM Softw. Eng.2, ISSTA, Article ISSTA081 (June 2025), 24 pa...

    2025 doi

  58. [67]

    Xiaojun Xu, Chang Liu, Qian Feng, Heng Yin, Le Song, and Dawn Song. 2017. Neural network-based graph embedding for cross-platform binary code similarity detection. InProceedings of the 2017 ACM SIGSAC Conference on Computer and Communications Security. 363–376. doi:10.1145/313...

    2017

  59. [68]

    Xiangzhe Xu, Zhou Xuan, Shiwei Feng, Siyuan Cheng, Yapeng Ye, Qingkai Shi, Guanhong Tao, Le Yu, Zhuo Zhang, and Xiangyu Zhang. 2023. PEM: Repre- senting Binary Program Semantics for Similarity Analysis via a Probabilistic Execution Model. InProceedings of the 31st ACM Joint Eu...

    2023

  60. [69]

    Yifei Xu, Zhengzi Xu, Bihuan Chen, Fu Song, Yang Liu, and Ting Liu. 2020. Patch based vulnerability matching for binary programs. InProceedings of the 29th ACM SIGSOFT International Symposium on Software Testing and Analysis. 376–387. doi:10.1145/3395363.3397361

    2020

  61. [70]

    Chengfeng Ye, Anshunkang Zhou, and Charles Zhang. 2026. Enhancing Semantic- Aware Binary Diffing with High-Confidence Dynamic Instruction Alignment. In Network and Distributed Systems Security (NDSS) Symposium. doi:10.14722/ndss. 2026.240663

    2026

  62. [71]

    Zeping Yu, Rui Cao, Qiyi Tang, Sen Nie, Junzhou Huang, and Shi Wu. 2020. Order matters: Semantic-aware neural networks for binary code similarity detection. InProceedings of the AAAI conference on artificial intelligence, Vol. 34. 1145–1152. doi:10.1609/aaai.v34i01.5466

    2020 doi

  63. [72]

    Zeping Yu, Wenxin Zheng, Jiaqi Wang, Qiyi Tang, Sen Nie, and Shi Wu. 2020. CodeCMR: Cross-Modal Retrieval For Function-Level Binary Source Code Match- ing. InAdvances in Neural Information Processing Systems, Vol. 33. Curran Asso- ciates, Inc., 3872–3883

    2020

  64. [73]

    Hang Zhang and Zhiyun Qian. 2018. Precise and accurate patch presence test for binaries. In27th USENIX Security Symposium (USENIX Security 18). 887–902

    2018

  65. [74]

    Liu Zhibo, Wang Huaijin, and Wang Shuai. 2026. The Unseen Delta: Characteriz- ing the Compiler Optimization Landscape via Top-Down Differential Analysis. In Proceedings of the 2026 International Symposium on Software Testing and Analysis (ISSTA ’26). doi:10.1145/3832164

    2026 doi

  66. [75]

    Fei Zuo, Xiaopeng Li, Patrick Young, Lannan Luo, Qiang Zeng, and Zhexin Zhang

  67. [1917]

    doi:10.1109/TDSC.2020.3041655

    2020

  68. [2019]

    InNetwork and Distributed Systems Security (NDSS) Symposium

    Neural Machine Translation Inspired Binary Code Similarity Compari- son beyond Function Pairs. InNetwork and Distributed Systems Security (NDSS) Symposium. doi:10.14722/ndss.2019.23492

    2019

Pith tools

Reviewed August 16, 2026 · model on record in the stance chip above.