Pith. sign in

REVIEW 4 major objections 4 minor 50 references

Tady: A Neural Disassembler without Structural Constraint Violations

T0 review · 4 major / 4 minor · reviewed 2026-08-15 · deepseek-v4-flash

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

Pith's one-line read Tady claims that post-dominance-based pruning eliminates all structural constraint violations in neural disassembly while preserving instruction-level accuracy.

desk verdict A genuinely new PDT-based approach to disassembly consistency, but the 'zero violations' claim only holds for the patterns the PDT happens to catch; cross-component and CF/NCF overlaps get through. read the letter →

arxiv 2506.13323 v1 pith:HPCAIGY4 submitted 2025-06-16 cs.CR cs.AIcs.LGcs.SE

Siliang Qin , Fengrui Yang , Hao Wang , Bolun Zhang , Zeyu Gao , Chao Zhang , Kai Chen This is my paper · ORCID
classification cs.CRcs.AIcs.LGcs.SE
keywords binarydisassemblypost-dominatortreestructuralconstraintsneuraldisassemblercontrol-flowintegritydynamicprogrammingpruningreverseengineeringx86-64
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

This paper tries to establish that the structural failures common in neural disassembly—missing jump targets, dead-end instruction sequences, and overlapping instructions—can be characterized by post-dominance relations, detected in linear time, and eliminated by construction through a pruning step. The proposed system, Tady, combines a trace-aware neural model with a post-dominator-tree-based post-processor, and reports that its final output has zero structural constraint violations while keeping instruction-level precision and recall competitive with existing rule-based and neural disassemblers. A sympathetic reader would care because disassembly consistency, not just per-instruction accuracy, is what downstream tools such as decompilers and binary similarity detectors actually consume; outputs that violate control-flow structure are unusable no matter how high their F1 score looks. The same detection machinery also exposes errors in existing dataset labels that had previously been treated as ground truth.

What carries the argument

The load-bearing object is the post-dominator tree (PDT) of the superset control-flow graph, in which every byte address is a candidate instruction node and each weakly connected component is rooted at an artificial virtual exit. Because post-dominance captures 'every path from a node to the exit,' a false node above a true node is proof of a broken path, and two true non-control-flow children under one parent are proof of overlap. The dynamic-programming pruning algorithm—weight propagation upward through the tree followed by breadth-first collection—selects the maximum-confidence subtree that respects the tree's structure, which is what turns probabilistic predictions into a guaranteed-consistent disassembly.

What would settle it

Construct a small x86-64 binary whose function installs a signal handler, cause a division-by-zero after a fall-through instruction, and run Tady; if the handler entry is pruned or the fall-through successor is forced to remain, the post-dominator assumption is violated and the no-violations guarantee does not correspond to real execution. The paper itself identifies signal-based control flow as a limitation, so this is the sharpest place to test the claim.

Watch

Extended reading notes

Core claim

On the paper's own terms, the central claim is that a valid disassembly is exactly a subset of candidate instructions whose post-dominator tree satisfies two properties—path integrity, where every true instruction's ancestors up to the root are true, and non-overlap, where no node has two true non-control-flow children—and that the disassembly problem can be regularized by enforcing these properties on a superset control-flow graph. Tady builds the post-dominator tree of the superset graph, assigns every candidate node a neural confidence score, and then solves a maximum-weight subtree problem over that tree using dynamic programming. The paper reports that this removes 100 percent of the detected structural violations in Tady's output across all evaluated binaries, including obfuscated ones, and that the same post-processor also cleans the outputs of other neural disassemblers while often improving their F1 scores.

Load-bearing premise

The central assumption is that the post-dominator tree built from a superset graph, in which call edges are omitted, indirect jumps may be unresolved, and each weakly connected component is given an artificial exit, faithfully represents the binary's real execution paths; if that graph is wrong, the pruning guarantee only certifies consistency with the wrong graph.

Editorial extensions

If this is right

  • Downstream tools can consume Tady's output without first repairing control-flow graphs, since path integrity and non-overlap hold by construction.
  • The post-dominator traversal becomes a cheap, label-free quality gate: it flags labeling errors in disassembly datasets, so dataset maintainers can locate false positives and false negatives without a second tool.
  • The pruning step is a drop-in regularizer for neural disassemblers: feeding another model's scores through the same maximum-weight-subtree procedure removes structural violations and, in most reported cases, raises F1 rather than lowering it.
  • Because the whole pipeline is linear in binary size, consistency enforcement does not change the practical scalability of superset disassembly.

Reading between the lines

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

  • A natural next test, beyond the paper, is whether the same post-dominator pruning transfers to other instruction set architectures; the constraints as formulated are architecture-agnostic, but the paper only evaluates x86 and x86-64 binaries.
  • The guarantee is conditional on the quality of the superset control-flow graph: if real execution can follow a path the graph omits, such as signal-handler transfer, pruning can still declare a valid output that is invalid with respect to the actual hardware. The paper acknowledges this for exception-induced control flow but does not model it.
  • A testable extension is to use the violation detector as a training-signal generator: relabel the false positives and false negatives it finds in training corpora and retrain the model, which should reduce the residual errors that pruning currently has to clean up.
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

4 major / 4 minor

Summary. This paper introduces Tady, a neural disassembler for x86/x86-64 that combines a transformer-based model with a post-dominator tree (PDT) based post-processing step. The authors formalize three structural constraint violations (missing post-dominator, dead-end sequence, overlapping instructions), show that such violations appear in the outputs of existing neural and rule-based disassemblers and even in dataset labels, and propose a linear-time violation detection algorithm. The post-processing step prunes the PDT to remove inconsistent nodes while maximizing the sum of confidence scores, and the authors claim this completely eliminates all structural constraint violations. Evaluation on Pangine, Assemblage, x86-sok, RW, Obf-Benchmark, and Quarks shows competitive F1 scores and high efficiency. The paper also releases code and models.

Significance. If the central claim were correct, Tady would be a practically important contribution: a fast, learning-based disassembler whose output is guaranteed to satisfy basic structural soundness, with a reusable post-processing step for other neural disassemblers. The paper has clear strengths: the algorithms are specified in sufficient detail to reproduce, the evaluation covers diverse datasets including obfuscated binaries, the detection tool finds real label errors without ground truth, and the artifact is publicly released. However, the guarantee of complete elimination of violations is not actually delivered by the pruning algorithm as described, which limits the significance of the main claim to the narrower set of constraints that the PDT sibling structure can express.

major comments (4)
  1. [Section 2.2 and Algorithm 3] The pruning algorithm enforces non-overlap only by keeping at most one non-control-flow (NCF) child per PDT node (Algorithm 3, lines 11–15 and 21–25). This is insufficient to guarantee the absence of overlapping instructions. Two overlapping instructions need not be siblings under the PDT: they can lie in different weakly connected components (e.g., an unconditional jump at 0x100 and an overlapping instruction starting at 0x101, with separate WCCs because call edges are omitted and no control-flow edge connects them), or one can be a control-flow instruction and the other a non-control-flow instruction at different depths. In both cases no PDT node has two NCF children, so both candidates are retained if their scores are positive, and the final output contains overlapping instructions. Consequently, the abstract and Section 7 claims that Tady 'eliminates' or 'completely eliminates' structural constraint violations are not supported by the algorithm as described; at most it eliminates the specific pattern of multiple NCF siblings under one PDT node, and no overlap that is not of that form.
  2. [Section 4.2] Because the pruning guarantee is incomplete, the sentence 'Since our pruning algorithm eliminates all of the violations, we report the error rate before pruning' overstates the result. The after-pruning violation counts, in particular overlapping-instruction counts, should be reported. The current Table 1 gives only before-pruning error rates, so the reader cannot verify the central claim. This is not purely cosmetic: the counterexample in the previous comment shows that after-pruning OI violations can remain, so the reported numbers would not be zero in general, and Table 2's OI statistics, which rely on the same E3 sibling-check, likely undercount the true number of overlapping-instruction errors in the labels.
  3. [Section 5] The paper itself concedes that the post-dominance assumption underlying the constraints fails for signal-based hardware exceptions. This is a legitimate scoping statement, but it contradicts the unconditional wording used in the abstract ('without structural constraint violations') and in the conclusion ('completely eliminate the violations'). The claims need to be restated with the scope that the paper actually establishes, and the algorithm should be described as enforcing constraints modulo the admitted exception, not as eliminating all possible violations.
  4. [Section 3.2] The statement that the pruned tree 'represents a valid disassembly solution that maximizes confidence scores while satisfying all structural constraints' is ambiguous. The dynamic program in Algorithms 2–3 maximizes the sum of scores subject to the two invariants it actually encodes (path integrity and at most one NCF child per node), not subject to the full non-overlap constraint as defined in Section 2.1. Because the constraint set is not fully enforced, the optimality claim should be scoped to the implemented invariants rather than to 'all structural constraints'.
minor comments (4)
  1. [Table 3] The caption should define the 'B' and 'A' states as before and after pruning, and it should explain that TadyA is the model trained on the composite dataset, since the name first appears in the table without definition in the main text.
  2. [Throughout] The dataset name is written inconsistently as 'x86-sok' in the text and 'X86-Sok' in Tables 1 and 2; please unify the spelling.
  3. [Sections 2.2 and 3] The workflow description says the superset CFG edges include call edges, while Section 2.2 says call edges are not connected during WCC construction; this apparent contradiction should be clarified so the reader understands that call edges are present in the CFG but deliberately omitted for the PDT construction.
  4. [Section 3.1.2] The description of the reachability mask says collection 'stops when encountering conditional jumps for simplicity'; this design choice may limit the mask's ability to represent long-range reachability, and it would be helpful to state its impact on the model's capability.

Circularity Check

0 steps flagged · score 0.0 of 10

No meaningful circularity: the post-pruning absence of violations is an enforced design property, while accuracy is measured against external labels.

full rationale

The paper's derivation is not circular. The structural constraints (MPD, DES, OI) are defined from post-dominance relations over a superset CFG (Sections 2.1-2.3), independently of Tady's learned scores and of the evaluation labels; the post-dominator tree is computed by the standard Lengauer-Tarjan algorithm over graph structure, and the violation definitions do not use Tady's outputs. The pruning algorithm (Algorithm 3) enforces the same constraints by construction, so the claim that the final tree has no detected violations is an enforcement property rather than an empirical prediction; this is a framing tautology, not a circular derivation, and it does not contaminate the accuracy results, which are measured against external labels (the Pangine-trained model is evaluated on Assemblage, x86-sok, rw, quarks, and obf-benchmark). No load-bearing self-citation, imported uniqueness theorem, or ansatz-by-citation is present; the cited prior neural and rule-based disassemblers are baselines rather than premises. The skeptical non-overlap gap (overlaps across weakly connected components or between control-flow/non-control-flow sibling pairs are not checked by Algorithm 1/E3) and the Section 5 signal-exception limitation are correctness and coverage concerns about whether all real violations are captured, not circularity: even if those concerns are valid, the derivation does not reduce to its own inputs. The paper is self-contained against external benchmarks, so the honest finding is no significant circularity.

Assumptions & free parameters 8 free parameters · 6 assumptions · 1 invented entities

The central claim rests on the post-dominance model of valid disassembly, the correctness of the PDT construction over a superset CFG, and the pruning algorithm's ability to preserve accuracy while enforcing constraints. The ledger reflects that no new physical entities are postulated; the main invented element is the virtual exit node. The model hyperparameters are hand-selected and not systematically swept, so accuracy numbers should be read as point estimates for one configuration.

free parameters (8)
  • Focal loss alpha = 0.8
    Hand-set in Section 4.1; no sensitivity analysis reported; it affects classifier calibration and therefore pruning outcomes.
  • Focal loss gamma = 4.0
    Hand-set in Section 4.1; no sensitivity analysis reported; it changes how hard examples are weighted.
  • Learning rate = 1e-3
    AdamW learning rate chosen in Section 4.1; accuracy results depend on it.
  • Transformer hidden and intermediate sizes = 16 and 32
    Architecture hyperparameters in Section 4.1; no ablation varying model capacity is reported.
  • Sliding window size = 64 on each side
    Chosen in Section 4.1; it defines the local context available to masked attention.
  • Attention heads and mask assignment = 4 heads, 3 reachability masks and 1 overlap mask
    Hand-selected in Section 4.1; the paper ablates MSWA vs SWA but not the head allocation.
  • Sequence chunk length and batch size = 8192 and 32
    Set in Section 4.1 and Section 4.4; changes throughput and potentially accuracy through context truncation.
  • Score encoding for non-neural tools = true nodes +1, false nodes -1; XDA uses inverse sigmoid of start probability
    Introduced in Section 4.2; this arbitrary scale affects how the pruning algorithm treats rule-based and XDA outputs.
assumptions (6)
  • domain assumption Post-dominance relations on the superset CFG characterize valid disassembly structure.
    Section 2.1 defines Missing Post-Dominator and Dead-End Sequence using post-dominance; Section 5 concedes exceptions for signal-based hardware exceptions.
  • domain assumption Valid disassembly never contains overlapping instructions.
    Section 2.1 defines Overlapping Instructions as a violation; the authors acknowledge exceptions for lock prefixes and some obfuscation.
  • domain assumption A fall-through non-control-flow instruction is immediately post-dominated by the next instruction in memory.
    This is used in Algorithm 1 and the pruning logic; Section 5 states it holds except for signal-based hardware exceptions.
  • domain assumption The superset CFG, with call edges omitted and unresolved indirect edges allowed, is sufficient for PDT-based enforcement.
    Section 2.2 omits call edges to bound WCC size and claims the method works with partial control-flow information, but no evaluation isolates the effect of these omissions.
  • ad hoc to paper Adding a virtual exit node and linking terminal SCC representative jumps preserves the post-dominance relations needed by the constraints.
    Section 2.2 introduces this construction to make the PDT a single rooted tree; it is a paper-specific modeling choice that changes exit semantics.
  • standard math Lengauer-Tarjan and standard WCC/SCC algorithms compute post-dominators correctly.
    The paper relies on the standard algorithm as cited in [19]; no custom correctness proof is given.
invented entities (1)
  • Virtual exit node per weakly connected component
    purpose: Gives each WCC a single tree root so post-dominance forms a post-dominator tree.
    Introduced in Section 2.2 as a graph-theoretic device; it alters the post-dominance relation and has no counterpart in the binary's actual semantics.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Tady: A Neural Disassembler without Structural Constraint Violations." pith.science (2026). https://pith.science/paper/HPCAIGY4

@misc{pith2026250613323,
  author       = {Pith},
  title        = {Pith review of: Tady: A Neural Disassembler without Structural Constraint Violations},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/HPCAIGY4}},
  note         = {Machine review of arXiv:2506.13323}
}
read the original abstract

Disassembly is a crucial yet challenging step in binary analysis. While emerging neural disassemblers show promise for efficiency and accuracy, they frequently generate outputs violating fundamental structural constraints, which significantly compromise their practical usability. To address this critical problem, we regularize the disassembly solution space by formalizing and applying key structural constraints based on post-dominance relations. This approach systematically detects widespread errors in existing neural disassemblers' outputs. These errors often originate from models' limited context modeling and instruction-level decoding that neglect global structural integrity. We introduce Tady, a novel neural disassembler featuring an improved model architecture and a dedicated post-processing algorithm, specifically engineered to address these deficiencies. Comprehensive evaluations on diverse binaries demonstrate that Tady effectively eliminates structural constraint violations and functions with high efficiency, while maintaining instruction-level accuracy.

Figures

Figures reproduced from arXiv: 2506.13323 by the authors.

Figure 1
Figure 1. Example of Constraint Violations discovered in the labels provided by x86-Sok dataset. (a) Missing Post-Dominator. [PITH_FULL_IMAGE:figures/full_fig_p003_1.png] view at source ↗
Figure 2
Figure 2. Example of a superset Control Flow Graph and its [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. Patterns of violations. (a) Missing Post-Dominator. [PITH_FULL_IMAGE:figures/full_fig_p005_3.png] view at source ↗
Figures from the paper (6 more)
Figure 4
Figure 4. Figure 4: shows our disassembler’s workflow. We first con￾duct a superset disassembly over the executable section to extract instructions and their address connections. They are then fed into our model to assign scores to each address. Si￾multaneously, we construct a superset CF…
Figure 6
Figure 6. Figure 6: Sliding Window Attention with an Example Reacha [PITH_FULL_IMAGE:figures/full_fig_p006_6.png]
Figure 7
Figure 7. Figure 7: Global Message Passing With Selective Attention. [PITH_FULL_IMAGE:figures/full_fig_p007_7.png]
Figure 8
Figure 8. Figure 8: Run time comparison of the disassemblers. [PITH_FULL_IMAGE:figures/full_fig_p012_8.png]
Figure 11
Figure 11. Figure 11: Peak Memory Usage for PDT Construction. duces memory requirements for tree construction. Since most WCCs are concentrated within a comparatively small size range, memory usage is primarily dominated by storing edges. Consequently, the memory needed to process individ￾…
Figure 10
Figure 10. Figure 10: Time Consumption of the Algorithms. As depicted in [PITH_FULL_IMAGE:figures/full_fig_p013_10.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

50 extracted references · 44 canonical work pages

  1. [1]

    Collberg, Vijay Ganesh, Zack Newsham, and Alexander Pretschner

    Sebastian Banescu, Christian S. Collberg, Vijay Ganesh, Zack Newsham, and Alexander Pretschner. Code obfus- cation against symbolic execution attacks. In Stephen Schwab, William K. Robertson, and Davide Balzarotti, editors, Proceedings of the 32nd Annual Conference on Computer Security Applications, ACSAC 2016, Los An- geles, CA, USA, December 5-9, 2016, ...

    work page 2016

  2. [2]

    BYTEWEIGHT: Learn- ing to Recognize Functions in Binary Code

    Tiffany Bao, Jonathan Burket, Maverick Woo, Rafael Turner, and David Brumley. BYTEWEIGHT: Learn- ing to Recognize Functions in Binary Code. In Kevin Fu and Jaeyeon Jung, editors, Proceedings of the 23rd USENIX Security Symposium, San Diego, CA, USA, Au- gust 20-22, 2014, pages 845–860. USENIX Association, 2014

    work page 2014

  3. [3]

    Ahoy SAILR! There is No Need to DREAM of C: A Compiler-Aware Structuring Algorithm for Binary Decompilation

    Zion Leonahenahe Basque, Ati Priya Bajaj, Wil Gibbs, Jude O’Kain, Derron Miao, Tiffany Bao, Adam Doupé, Yan Shoshitaishvili, and Ruoyu Wang. Ahoy SAILR! There is No Need to DREAM of C: A Compiler-Aware Structuring Algorithm for Binary Decompilation. In Da- vide Balzarotti and Wenyuan Xu, editors, 33rd USENIX Security Symposium, USENIX Security 2024, Phila...

    work page 2024

  4. [4]

    JAX: Composable transformations of Python+NumPy programs

    James Bradbury, Roy Frostig, Peter Hawkins, Matthew James Johnson, Chris Leary, Dougal Maclau- rin, George Necula, Adam Paszke, Jake VanderPlas, Skye Wanderman-Milne, and Qiao Zhang. JAX: Composable transformations of Python+NumPy programs. http://github.com/jax-ml/jax, 2018

    work page 2018

  5. [5]

    Intraprocedu- ral Static Slicing of Binary Executables

    Cristina Cifuentes and Antoine Fraboulet. Intraprocedu- ral Static Slicing of Binary Executables. In 1997 Inter- national Conference on Software Maintenance (ICSM ’97), 1-3 October 1997, Bari, Italy, Proceedings, page

    work page 1997

  6. [6]

    John Gough

    Cristina Cifuentes and K. John Gough. Decompilation of Binary Programs. Softw Pract Exp, 25(7):811–829, 1995

    work page 1995

  7. [7]

    Disas- sembly as Weighted Interval Scheduling with Learned Weights

    Antonio Flores-Montoya, Junghee Lim, Adam Seitz, Akshay Sood, Edward Raff, and James Holt. Disas- sembly as Weighted Interval Scheduling with Learned Weights. In 2025 IEEE Symposium on Security and Pri- vacy (SP), pages 3033–3050. IEEE Computer Society, April 2025

    work page 2025

  8. [8]

    Antonio Flores-Montoya and Eric M. Schulte. Datalog Disassembly. In Srdjan Capkun and Franziska Roesner, editors, 29th USENIX Security Symposium, USENIX Security 2020, August 12-14, 2020, pages 1075–1092. USENIX Association, 2020

    work page 2020

Show all 50 references
  1. [9]

    Deep Learning

    Ian Goodfellow, Yoshua Bengio, and Aaron Courville. Deep Learning. MIT Press, 2016

    2016

  2. [10]

    DEEPVSA: Facilitating Value-set Analy- sis with Deep Learning for Postmortem Program Anal- ysis

    Wenbo Guo, Dongliang Mu, Xinyu Xing, Min Du, and Dawn Song. DEEPVSA: Facilitating Value-set Analy- sis with Deep Learning for Postmortem Program Anal- ysis. In Nadia Heninger and Patrick Traynor, editors, 28th USENIX Security Symposium, USENIX Security 2019, Santa Clara, CA, U...

    2019

  3. [11]

    Code is not natural language: Unlock the power of semantics-oriented graph representation for binary code similarity detection

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

    2024

  4. [12]

    Flax: A neural network library and ecosystem for JAX

    Jonathan Heek, Anselm Levskaya, Avital Oliver, Marvin Ritter, Bertrand Rondepierre, Andreas Steiner, and Marc van Zee. Flax: A neural network library and ecosystem for JAX. http://github.com/google/flax, 2024

    2024

  5. [13]

    Hex-Rays. IDA Pro. https://hex-rays.com, 2025

    2025

  6. [14]

    A Semantics-Based Hybrid Approach on Binary Code Similarity Comparison

    Yikun Hu, Hui Wang, Yuanyuan Zhang, Bodong Li, and Dawu Gu. A Semantics-Based Hybrid Approach on Binary Code Similarity Comparison. IEEE Trans. Software Eng., 47(6):1241–1258, 2021

    2021

  7. [15]

    Obfuscator-LLVM - Software Protection for the Masses

    Pascal Junod, Julien Rinaldini, Johan Wehrli, and Julie Michielin. Obfuscator-LLVM - Software Protection for the Masses. In Paolo Falcarin and Brecht Wyseur, editors, 1st IEEE/ACM International Workshop on Soft- ware Protection, SPRO 2015, Florence, Italy, May 19, 2015, pages ...

    2015

  8. [16]

    Ammar Ben Khadra, Dominik Stoffel, and Wolf- gang Kunz

    M. Ammar Ben Khadra, Dominik Stoffel, and Wolf- gang Kunz. Speculative disassembly of binary code. In Daniel Große and Rolf Drechsler, editors, Methoden Und Beschreibungssprachen Zur Modellierung Und Ver- ifikation von Schaltungen Und Systemen, MBMV 2017, Bremen, Germany, Febr...

    2017

  9. [17]

    Chris Lattner and Vikram S. Adve. LLVM: A Com- pilation Framework for Lifelong Program Analysis & Transformation. In 2nd IEEE / ACM International Sym- posium on Code Generation and Optimization (CGO 2004), 20-24 March 2004, San Jose, CA, USA , pages 75–88, San Jose, CA, USA, 2...

    2004

  10. [18]

    Instruc- tion2vec: Efficient preprocessor of assembly code to detect software weakness with CNN

    Yongjun Lee, Hyun Kwon, Sang-Hoon Choi, Seungho Lim, Sung Hoon Baek, and Ki-Woong Park. Instruc- tion2vec: Efficient preprocessor of assembly code to detect software weakness with CNN. Applied Sciences, 9(19):4086, 2019

    2019

  11. [19]

    A fast algorithm for finding dominators in a flowgraph

    Thomas Lengauer and Robert Endre Tarjan. A fast algorithm for finding dominators in a flowgraph. ACM Transactions on Programming Languages and Systems (TOPLAS), 1(1):121–141, 1979

    1979

  12. [20]

    On the generation of disassembly ground truth and the evalua- tion of disassemblers

    Kaiyuan Li, Maverick Woo, and Limin Jia. On the generation of disassembly ground truth and the evalua- tion of disassemblers. Proceedings of the 2020 ACM Workshop on Forming an Ecosystem Around Software Transformation, 2020

    2020

  13. [21]

    PalmTree: Learn- ing an assembly language model for instruction embed- ding

    Xuezixiang Li, Qu Yu, and Heng Yin. PalmTree: Learn- ing an assembly language model for instruction embed- ding. Proceedings of the 2021 ACM SIGSAC Confer- ence on Computer and Communications Security, 2021

    2021

  14. [22]

    Neutron: An attention-based neural decompiler

    Ruigang Liang, Ying Cao, Peiwei Hu, and Kai Chen. Neutron: An attention-based neural decompiler. Cyber- security, 4(1):5, 2021

    2021

  15. [23]

    Girshick, Kaiming He, and Piotr Dollár

    Tsung-Yi Lin, Priya Goyal, Ross B. Girshick, Kaiming He, and Piotr Dollár. Focal loss for dense object detec- tion. 2017 IEEE International Conference on Computer Vision (ICCV), pages 2999–3007, 2017

    2017

  16. [24]

    Cullen Linn and Saumya K. Debray. Obfuscation of executable code to improve resistance to static disassem- bly. In Conference on Computer and Communications Security, CCS ’03, pages 290–299, New York, NY , USA,

  17. [25]

    Micinski

    Chang Liu, Rebecca Saul, Yihao Sun, Edward Raff, Maya Fuchs, Townsend Southard Pantano, James Holt, and Kristopher K. Micinski. Assemblage: Automatic binary dataset construction for machine learning. ArXiv, abs/2405.03991, 2024

    2024 arXiv

  18. [26]

    Decoupled weight decay regularization

    Ilya Loshchilov and Frank Hutter. Decoupled weight decay regularization. In International Conference on Learning Representations, 2017

    2017

  19. [27]

    Martín Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S. Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghe- mawat, Ian Goodfellow, Andrew Harp, Geoffrey Irv- ing, Michael Isard, Yangqing Jia, Rafal Jozefowicz, Lukasz Kaiser, Manj...

    2015

  20. [28]

    Miller, Yonghwi Kwon, Yi Sun, Zhuo Zhang, X

    Kenneth A. Miller, Yonghwi Kwon, Yi Sun, Zhuo Zhang, X. Zhang, and Zhiqiang Lin. Probabilistic disassembly. 2019 IEEE/ACM 41st International Con- ference on Software Engineering (ICSE), pages 1187– 1198, 2019

    2019

  21. [29]

    National Security Agency. Ghidra. https://github. com/NationalSecurityAgency/ghidra, 2025

    2025

  22. [30]

    TensorFlow-serving: Flexible, high-performance ML serving

    Christopher Olston, Noah Fiedel, Kiril Gorovoy, Jeremiah Harmsen, Li Lao, Fangwei Li, Vinu Rajashekhar, Sukriti Ramesh, and Jordan Soyke. TensorFlow-serving: Flexible, high-performance ML serving. ArXiv, abs/1712.06139, 2017

    2017 arXiv

  23. [31]

    SoK: All you ever wanted to know about x86/x64 bi- nary disassembly but were afraid to ask

    Chengbin Pang, Ruotong Yu, Yaohui Chen, Eric Kosk- inen, Georgios Portokalidis, Bing Mao, and Jun Xu. SoK: All you ever wanted to know about x86/x64 bi- nary disassembly but were afraid to ask. 2021 IEEE Symposium on Security and Privacy (SP), pages 833– 851, 2020

    2021

  24. [32]

    XDA: Accu- rate, robust disassembly with transfer learning

    Kexin Pei, Jonas Guan, David Williams-King, Jun- feng Yang, and Suman Sekhar Jana. XDA: Accu- rate, robust disassembly with transfer learning. ArXiv, abs/2010.00770, 2020

    2010 arXiv

  25. [33]

    Binary code disassembly for reverse engi- neering

    Marius Popa. Binary code disassembly for reverse engi- neering. Journal of Mobile, Embedded and Distributed Systems, 4:233–248, 2012

    2012

  26. [34]

    Popov, Saumya K

    Igor V . Popov, Saumya K. Debray, and Gregory R. Andrews. Binary obfuscation using signals. In USENIX Security Symposium, 2007

    2007

  27. [35]

    Multi-level cross-architecture binary code similarity metric

    Meng Qiao, Xiaochuan Zhang, Huihui Sun, Zhen Shan, Fudong Liu, Wenjie Sun, and Xingwei Li. Multi-level cross-architecture binary code similarity metric. Ara- bian Journal for Science and Engineering , 46:8603– 8615, 2021

    2021

  28. [36]

    Diffing_obfuscation_dataset

    Quarkslab. Diffing_obfuscation_dataset. https://github.com/quarkslab/diffing_ obfuscation_dataset, 2025

    2025

  29. [37]

    Sisco, Jonathan Balkind, Timothy Sher- wood, and Ben Hardekopf

    Zachary D. Sisco, Jonathan Balkind, Timothy Sher- wood, and Ben Hardekopf. Loop rerolling for hardware decompilation. Proceedings of the ACM on Program- ming Languages, 7:420–442, 2023

    2023

  30. [38]

    Binary Ninja

    Vector 35 Inc. Binary Ninja. https://binary.ninja, 2025

    2025

  31. [39]

    VMProtect

    VMProtect Software. VMProtect. https://vmpsoft. com/vmprotect/overview, 2025

    2025

  32. [40]

    CLAP: Learning transfer- able binary code representations with natural language supervision

    Hao Wang, Zeyu Gao, Chao Zhang, Zihan Sha, Mingyang Sun, Yuchen Zhou, Wenyu Zhu, Wenju Sun, Han Qiu, and Xiangwei Xiao. CLAP: Learning transfer- able binary code representations with natural language supervision. Proceedings of the 33rd ACM SIGSOFT International Symposium on S...

    2024

  33. [41]

    CEBin: A cost-effective framework for large-scale binary code similarity detection

    Hao Wang, Zeyu Gao, Chao Zhang, Mingyang Sun, Yuchen Zhou, Han Qiu, and Xiangwei Xiao. CEBin: A cost-effective framework for large-scale binary code similarity detection. Proceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis, 2024

    2024

  34. [42]

    jTrans: Jump-aware transformer for binary code similarity de- tection

    Hao Wang, Wenjie Qu, Gilad Katz, Wenyu Zhu, Zeyu Gao, Han Qiu, Jianwei Zhuge, and Chao Zhang. jTrans: Jump-aware transformer for binary code similarity de- tection. Proceedings of the 31st ACM SIGSOFT Inter- national Symposium on Software Testing and Analysis, 2022

    2022

  35. [43]

    Hamlen, Murat Kantarcioglu, and Bhavani M

    Richard Wartell, Yan Zhou, Kevin W. Hamlen, Murat Kantarcioglu, and Bhavani M. Thuraisingham. Differ- entiating code from data in x86 binaries. In ECML/P- KDD, 2011

    2011

  36. [44]

    Yapeng Ye, Zhuo Zhang, Qingkai Shi, Yousra Aafer, and X. Zhang. D-ARM: Disassembling ARM binaries by lightweight superset instruction interpretation and graph modeling. 2023 IEEE Symposium on Security and Privacy (SP), pages 2391–2408, 2023

    2023

  37. [45]

    Program understanding approach for binary code based on data flow analysis

    Li Yong-cheng. Program understanding approach for binary code based on data flow analysis. Computer Engineering, 2010

    2010

  38. [46]

    DeepDi: Learning a relational graph convolutional network model on instructions for fast and accurate disassem- bly

    Sheng Yu, Yu Qu, Xunchao Hu, and Heng Yin. DeepDi: Learning a relational graph convolutional network model on instructions for fast and accurate disassem- bly. In USENIX Security Symposium, pages 2709–2725. USENIX Association, 2022

    2022

  39. [47]

    Method based on data flow analysis to understanding binary program

    Wu Zhi-yong. Method based on data flow analysis to understanding binary program. Computer Engineering and Applications, 2010

    2010

  40. [48]

    Pack the output file

    Li Zhoujun. Disassembly method based on control flow refining. Journal of Tsinghua University, 2011. Appendix A Complexity Analysis Our pre-processing step involves a superset disassembly, where decoding occurs at every possible address. Although this step can be parallelized ...

    2011

  41. [188]

    IEEE Computer Society, 1997

    1997

  42. [2003]

    Association for Computing Machinery

Pith tools

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