Pre-Training Representations of Binary Code Using Contrastive Learning
Authors: Yifan Zhang
Chen Huang
Yueke Zhang
Huajie Shao
Kevin Leach
Yu Huang
Venue: Accepted by TMLR ()

Abstract: Binary code analysis and comprehension is critical to applications in reverse engineering and computer security tasks where source code is not available. Unfortunately, unlike source code, binary code lacks semantics and is more difficult for human engineers to understand and analyze. In this paper, we present ContraBin, a contrastive learning technique that integrates source code and comment information along with binaries to create an embedding capable of aiding binary analysis and comprehension tasks. Specifically, we present three components in ContraBin: (1) a primary contrastive learning method for initial pre-training, (2) a simplex interpolation method to integrate source code, comments, and binary code, and (3) an intermediate representation learning algorithm to train a binary code embedding. We further analyze the impact of human-written and synthetic comments on binary code comprehension tasks, revealing a significant performance disparity. While synthetic comments provide substantial benefits, human-written comments are found to introduce noise, even resulting in performance drops compared to using no comments. These findings reshape the narrative around the role of comment types in binary code analysis. We evaluate the effectiveness of ContraBin through four indicative downstream tasks related to binary code: algorithmic functionality classification, function name recovery, code summarization, and reverse engineering. The results show that ContraBin considerably improves performance on all four tasks, measured by accuracy, mean of average precision, and BLEU scores as appropriate. ContraBin is the first language representation model to incorporate source code, binary code, and comments into contrastive code representation learning and is intended to contribute to the field of binary code analysis. The dataset used in this study is available for further research.

Published in Transactions on Machine Learning Research (09/2025)
Pre- Training Representations of Binary Code Using Con trastive Learning
Yifan Zhang
Deportment of Computer Science Vanderbilt University
Chen Huang
chen Crw.s.edu........
Department Computer Science
National University of Singapore
Yueke Zhang
yucke..hhng@@vanderrtii edu
Department of Computer Science Vanderbilt University
Huajie Shao
hshao @umm. edu
Department of Computer Science College of William Mary
Kevin Leach
kevin, wwwnndrrbbttdtteeoooooo edu
Department of Computer Science Vanderbilt University
Yu Huang
Saaluaann@@aurrrbiiiii edu
Department of Computer Science Vanderbilt University
Reviewed on OpenReview: httpee/eeeeeitppp//////eeeereeer
Abstract
Binary code analysis and comprchension critical to applications in reverse engincering and computer security tasks where source code not available. Unfortunately, unlike source code, binary code lacks semantics and more difficult for human engineers to understand and analyze. In this paper, we present CONTRABIN, a contrastive learning technique that integrates source code and comment information along with binaries to create embed- ding capable of aiding binary analysis and comprehension tasks. Specifically, we present three components in CONTRABIN: (1) primary contrastive learning method for initial pre-training, (2) simplex interpolation method to integrate source code, comments, and binary code, and (3) an intermediate representation learning algorithm to train a binary code embedding. We further analyze the impact human-written and synthetic comments on binary code comprehension tasks, revealing a significant performance disparity. While synthetic comments provide substantial benefits, human-written comments found to in- troduce noise, even resulting in performance drops compared to using comments. These findings reshape the narrative around the role of comment types in binary code analysis. We evaluate the effectiveness of CONTRABIN through four indicative downst tasks re- lated to binary code: algorithmic functionality classification, function name recovery, code summarization, and reverse engineering. The results show that CONTRABiu Bin considerably improves performance on all four tasks, measured by accuracy, mean of average precision, and BLEU scores appropriate. CONTRABIN is the first language representation model

---

Published in Transactions on Machine Learning Research (09/2025)
to incorporate source code, binary code, and comments into contrastive code representation learning and is intended to contribute to the field of binary code analysis. The dataset used in this study is available for further research.
1 Introduction
Binary code' provides valuable information about a program's content and behavior and is often the only available representation of program in certain cases, such legacy systems, proprietary software, and penetration testing (Harris & Miller, 2005). Binary code analysis is critical to many software related tasks, and understanding binary code can serve as a critical source of information about program content and behavior, and thus a foundation of many applications (Wang et al., 2000; Pierce & Mudge, 1994; Cifuentes et al., 1999; Giffin et al., 2004).
However, while understanding and analyzing binary code is essential for various tasks, there exists no prac- tical, generalizable strategy for comprehending binary code due to inherent characteristics: compared to source code and natural languages, binary code has very limited semantics, is substantially more difficult for humans to understand, and is much more difficult to analyze automatically.
Currently, binary code analysis is approached through two methods: (1) traditional static and dynamic analysis and (2) AT-based methods. Traditional methods use manual techniques and specific algorithms (e.g.. dataflow analysis), but are limited in their ability to be used across different platforms and applications (Bao et al., 2014; David et al., 2016; Aslanyan et al., 2020). Al-based methods use machine learning to capture both program structure and semantics, and have combined synlax, semantics, and structure to create embeddings for specific tasks (Guo et al., 2020; Lacomis et al., 2019; Chen et al., 2022b). However, few focus on large- scale pre-trained representations for binary code, which is a largely unexplored area (Feng et al., 2020; Guo et al., 2020), instead focusing primarily on source code or related syntactic structures like abstract syntax trees.
Considering the critical challenges needed to assist binary code analysis, in this paper, we present CONTRA- BIN, a novel contrastive learning model that combines simplex interpolation to approximate human gradual learning, and intermediate contrastive learning to produce high quality embedding for binary code. Large corpora of source code and documentation can be combined with corresponding compiled binary code to serve as a basis for an effective contrasting learning approach.
CONTRABIN consists of three components and an evaluation, illustrated in Figure 2. First, we leverage com- ments within the source code and the corresponding binary code (which can be obtained from compiling the source code), and randomly choose two of the three representations (i.e., source code, comments, and binary code) to conduct primary contrastive learning. Then, we design linear and non-linear simplex interpolation methods to interpolate two data embeddings and obtain an intermediate representation. Next, we introduce an intermediate contrastive learning approach to incorporate source code and comment information into binary code. Lastly, we evaluate the trained binary code embedding on three downstream tasks for binary code analysis to validate our model. We elaborate upon the design of CONTRABIN in Section 2.
The design of CONTRABIN is based on three key insights. First, we recognize that source code, comments, and their compiled binaries are different but semantically equivalent representations of program, forming rich multi-modal view. Second, we observe that the process of human documenting code and a compiler translating it share properties of gradual learning, as illustrated in Figure 1. We model this with simplex interpolation to create a unified learning process that bridges these different views. Finally, our approach leverages the principle of semantic dissimilarity: while these related artifacts represent the same program, they are inherently distinct from the artifacts of any other program. These insights form the foundation of our multi-modal contrastive learning framework, designed to produce effective embeddings for binary analysis.
In this paper, we use binary code to refer to both executable hinary functions and lifted aasembly/nntermenn represen- tations because they are trivially interchangeahle.
2

---

Published in Transactions on Machine Learning Research (09/2025)
Expert Programmer
Compiler/Decompiier
Conduct
Unknown Process
Perform
Human Analysis
Decompiiation
Comment
Binary Code
Code Writing
Complation
Source Code
Unknown Prooess
Figure 1: Illustration of the software compilation and human documentation process. Expert programmers can analyze source code to write comments or produce code based on comments. Compilers can compile source code and obtain binary code, whereas decompilers can decompile binary code and get source code.
To validate our approach, we evaluate CONTRABIN's pre-trained embeddings against several stale-of-the-at large-scale models (Liu et al., 2019; Feng et al., 2020; Guo et al., 2020; 2022a). While many existing models are designed primarily for source code, we make a best-effort comparison to establish a strong bascline for binary-focused representation learning. Our evaluation spans four indicative downstream tasks: (1) Binary Functional Algorithm Analysis the POJ-104 dataset (Mou et al., 2016); (2) Binary Function Name Recovery the DIRE dataset (Lacomis et al., 2019); and (3) Binary Code Summarization and (4) Binary Reverse Engineering, both on subsets of AnghaBench (Da Silva et al., 2021).
These tasks were chosen as they provide a comprehensive test of binary analysis and comprehension capa- bilities and permit a fair comparison with source-code-aware models. Our results show that CONTRABIN substantially outperforms current code analysis models on the vast majority of task-relevant metrics and achieves comparable performance others.
In conclusion, we claim the following contributions:
We present CONTRABIN, the first contrastive learning framework, to our knowledge, for learning reprosentations of LLVM Intermodiate Representation (IR). uniquely aligns three modalitics (source code, IR, and comments) using a two-slage process with simplex interpolation to create meaningful intermediate views.
We design a novel simplex interpolation method, inspired by multi-view and curriculum learning, that models gradual learning process to better align the high-level semantics of source code and comments with the low-level structure of binary code.
We provide key empirical finding on training data quality: concise, LLM-generated comments signif- icantly improve performance, while noisy, human-written comments degrade it, reshaping how natural language annotations should be leveraged in binary analysis.
Our extensive evaluation on four diverse tasks functionaai classification, name recovery, summa- rization, and reverse engineering shows that CONTRABIN consistently and significantly outperforms strong pre-trained baselines, demonstrating the broad applicability of its embeddings.
Collectively, these contributions are embodied in CONTRABIN, framework designed to significantly advance the state of binary code representation learning. By bridging the semantic gap between source code, natural language, and low-level binaries, our work provides a robust foundation for a wide range of security and reverse engineering applications. To facilitate further research and ensure the reproducibility of our results, we have made our complete implementation, pro-trained models, and all datascts publicly available.?
hhtp::///ennd..orrrrttttt//////
3

---

Published in Transactions on Machine Learning Research (09/2025)
Pre-trsining binary code representation
Triplet Data Preparation: (a)
Primaryy Contrastive Learning: (b) with naive St ist and Secondary Contrastive Leaming: (b) icl
Task Specitic Tine-Tunig::: (d)
(P]
"Enooders irtts lond with protriined mobels.
(b)
(c)
(d)
Comment
Oommeent Ferbecting
Simplex
Funciionaliy Classifiction
Mashinc
Anchored
Interp (81)
Gemenodd
Falrod Batch
Enoodlrr
Seeior
Function Ractvvry
Source Code
Source
Negattva
Entectting
Disaimilarity
Trahable Gradinnss
Brosdding
Positiin
Code Summer Lsilion
Trainale
Sinilrity
Desins
Enooder*
Leariing hiw BJ and Sor
Enbodd
Binary Code
Rivery
Reverse Engineering
Used for downstrearm tasks afte pre-training
Figure Overview of CONTRABIN's Training Framework. The framework consists of four components: (a) Triplet Data Preparation, where triplet data (source code, binary code, and comments) are created through compilation and machine-generated comments; (b) and (c) are collectively structured into two learning stages: (1) Primary Contrastive Learning, which selects a single reprosentation (naive SI) and applies batch-wise similarity and dissimilarity; and (2) Secondary Contrastive Learning, which generates interpolated representations using simplex interpolation (SI) and further aligns them. Finally, (d) Task- Specific Fine- Tene-Tuning applics the pre-trained embeddings to downstream tasks.
2 Approach
In this section, we describe CONTRABIN, our approach to obtain high quality representation for binary code that can be used for a swath of binary analysis and comprehension tasks. In practice, our goal is to augment stripped, semantics-dearth binaries with rich contextual information provided by comments and source code. At a high level, we use a large-scale pre-training task along with downstream tasks related to binary code. CONTRABIN leverages tuples of (source code, binary code, comments) from many different programs scraped from GitHub, which form the basis of contrastive learning task. The architecture of CONTRABIN is summarized in Figure 2, which consists of three components. Given source code, first generale comments using pre-trained models, compile each code snippel to emit binary code, and randomly choose two of the three code representations in each batch of triplets to conduct primary constrastive learning. Then, we derive embeddings for the triplets from our encoder as a simplex projection, and generate an intermediate representation based on random and learuable interpolation. Next, we train our encoder by intermediate castrvstive learning using anchored representation and intermediate representation (i.e., one of the three representations is anchored while the other two are not). Finally, we apply the trained binary code embedding to four downstream tasks to evaluate its performance.
Background In recent years, pre-trained representations have become a powerful tool in code analysis, offering the ability to leverage vast amounts of existing knowledge to improve the performance and gen- eralization of models. By pre-training on large datasets of source code and natural language comments, these representations capture essential patterns and semantics that are difficult to learn from binary code alone. In our approach, we utilize these pre-trained models to bridge the gap between the rich, high-level information available in source code and comments, and the lower-level, more abstract nature of binary code. This strategy allows model to develop deeper understanding of binary code by learning from multiple modalities, ultimately enhancing its ability to perform complex tasks in code analysis.
To achieve this, our approach is structured in several key stages, each building on the previous one to refine and improve the model's understanding of binary code. We begin by aligning the representations of source code, comments, and binary code through scries of pro-training steps designed to capture the muances of each modality. By progressively refining these embeddings, our model learns to effectively transfer knowledge between different forms of code representation, ensuring that the final binary code embedding is robust and
4

---

Published in Transactions on Machine Learning Research (09/2025)
semantically rich. The following sections detail each of these stages, illustrating how they contribute to the overall effectiveness of our methodology.
2.1 Primary Contrastive Learning
This subsection introduces the primary contrastive learning approach for the simplex interpolation. Recall that the conversion process between two representations can involve complex analyses (e.g., compilation) or creative human processes (e.g,, code comprehension). At the same time, no generalizable models have been trained on datasets containing binary code. This can lead to the cold start problem in representation learning (Contardo et al., 2014) when a new data representation (c.g., a novel program never seen before) emerges a syslem. Therefore, it challenging to capture their features the same scenario applies to binary code representation.
Comparison The initial phase of CONTRABIN reflects the carly learning stages individuals go through when encountering new concept, emulating it using st straightforward comparisons.
To mitigate this cold start problem, we adopt primary contrastive learning in the first step of model training. Specifically, use three representations of program: comments (i.e., summarization generated by code models), source code (i.e., as written by developers), and binary code (i.e., as emitted from a compiler), and randomly choose two of them to conduct contrastive learning, as shown in Figure 2. During this step, the simplex interpolation module is disabled:
this approach inspired by multi-view learning (Zhao al., 2017) computer vision, in which an object can have k views, and all of the views are exactly from the same object. In our model, either source code, binary code, comment represent the same program, modalilies views) of program to enrich the information in binary code
treat the three representations (also denoted
There are two steps in primary contrastive learning: manifold projection and batch-wise similarity compar- ison.
Manifold projection To perform primary contrastive learning, the vector representation for each input string (i.e., of instructions, source code, comments) is obtained by an encoding function fM that projects instance into manifold space M with dimension d In this paper, Fs, 24 and x, denote input string of source code tokens, binary code (assembly or IR lifted from binary), and comment of one program, while h,, hg, he E Rd are their corresponding vector representations. The batch-wise manifold projection is
H. fi((,))
He = (Xxo).
(1)
H₁ fix(X)),
where X,, X3 and Xe are the matrix representations of batch of programs, and He, H2 and He E Rexd are the matrix representations of batch of projected embedding. We use a single anchored encoder fa for encoding source code and comments and a trainable encoder f' for binary code. In this context, the use of the terms 'anchored' and 'trainable' refers to the fact that the parameters of the encoder used for encoding comments and source code will not be updated by any binary code. Only the binary code encoder is trainable. This design was made based on our carly experimental findings, in which we found that using binary code to update comments and source code resulted in an ineffective model due to the considerable differences between binary code and these other forms of representation. To optimize the training process and build upon existing knowledge, we utilized pretrained embeddings, allowing for more efficient adaptation to the task of binary code representation. This strategy reduces the need for training from scratch and enables a more effective fine-tuning process.
Batch-wise similarity comparison To align binary code representations with their corresponding source code and comments, we adopt a loss function inspired by CLIP (Radford al., 2021). This method leverages batch-wise similarity and dissimilarity between different program representations to update the model.
5

---

Published in Transactions on Machine Learning Research (09/2025)
Specifically, we compute the in-batch cross-similarity between the anchored representation (either comment or source code) and the trainable binary code representation as follows:
logits = Hej. H
(2)
where He/s and Hs represent the embeddings comments or source code and binary code, respectively, and the notation Hy indicates standard matrix multiplication. The resulting logits quantify the in-batch cross-similarity.
To ensure compatibility with the cross-entropy loss, convert the logits into probability distribution using the softmax function:
P = softmax(logits,, dim = -1).
(3)
Next, we compute the in-batch similarity of the representations within each modality:
sime/s Ho/s c/s sim, H,H,,
(4)
where sime/s and sim, represent the intra-batch similarities of the comment/soures code and binary code embeddings, respectively.
To construct the target distribution for the loss computation, we take the average of the intra-batch simi- larities and apply the softmax function:
simoff + sim, dim -1)
targets softmax
(5)
2
The loss function is then computed using the cross-entropy (CE) between the probability distributions of and targets:
= CE(P, targets).
(6)
By minimizing this loss, the model learns to align semantically similar binary code, source code, and comment embeddings in unified embedding space. Minimizing the cross-cntropy penalizes differences between P and largets, forcing the two distributions to become more similar. As largets reflects the similarity structure of embeddings, this process aligns P with it, effectively concentrating the distributions (reducing entropy) and pulling semantically related concepts closer in the embedding space.
Explanation of the loss function The loss function is designed to address the inherent differences bet ween binary code and higher-level code comments. By minimizing this loss, the model learns to position related concepts whether from binary code, source code, comments closely together in a unified embedding space. This approach enhances the model's ability to transfer knowledge across these diverse representations, leading to improved performance CLIP, this function is tailored to the specific needs binary code representation, ensuring that similar embeddings are aligned while distinct ones are separated. This loss function can then help align the binary code embedding closer to the representations of comments and binary code in the manifold M, thereby providing well-trained binary code embedding the starting point for subsequent steps. The model will then back propagate the loss and update the parameters.
downstream tasks. Although inspired by the contrastive loss used in
2.2 Secondary Contrastive Learning
To enhance the representation quality of binary code embeddings, secondary contrastive learning builds primary contrastive learning by integrating simplex interpolation and intermediate contrastive learning, In primary contrastive lcarning, naive interpolation is used, where single representation is selected without applying interpolation lechniques (as rllustrated in Figure 2). Secondary contrastive learning extends this by introducing two advanced simplex interpolation methods: linear interpolation for direct learning and non-lincar interpolation for customized learning. These methods generate diverse and exprossive views of program representations, enabling the model better capture semantic relationships among source code, binary code, and comments. Intermediate contrastive learning then operates across all views generated by

---

Published in Transactions on Machine Learning Research (09/2023)
Intermediate Representation
Embedding 1
h1
hinterp
Sigmoid
Embedding 2
h2
Fully Connected
ProjectionHead
@ A)
Concat
Interp NN
À Interpolation Index
SI Module
h1
h2
Learnable Simplex Interpolation Module
Interp NN Blocks
Figure Illustration of the Simplex Interpolation Process. The left side shows our linear interpolation pipeline, learning À to interpolate hı and h2, two of the he, h2 and hg. The right side provides one type of interpolation NN block, consisting of the structure of ProjectionHead, Sigmoid layer.
colly-connected layer, and the final
the simplex interpolation methods, providing a novel mechanism to align semantically related representations while preserving distinctions among unrelated ones. Figure 2 illustrates the integration and interaction of these components within a unified training pipeline.
Simplex interpolation for gradual learning After completing primary contrastive learning, we use simplex interpolation for gradual learning among the three representations, as shown in Figure 2 (a). Simplex interpolation is inspired by human translation (e.g., from source code to comment or vice versa) and the code compilation (or decompilation) process, in which conversion from reprosentation to the other involves intermediate thinking analysis. While acknowledge that the manifold assumption is common tool in understanding deep learning phenomena, its application here serves primarily to align with our color boxes discussed from Section 2.1 to Section 2.4. This assumption provides simplified framework to conceptualize the interpolation process, aiding in the explanation of our model's behavior binary code representation learning.
Analogy and extrapolation The subsequent portion suggests that CONTRABIN compares represen- tations of the same program to learn differences and similarities among programs.
We use both linear and non-linear simplex interpolation as part of a gradual learning approach to obtain increasingly expressive embeddings. Based on simplex interpolation theories (Thrampoulidis et al., 2022), we presume the intermediate representations between any of the two source code, binary code, and comments be different. view of the same program. The detailed steps shown follows:
Linear interpolation for direct learning We create two interpolation methods to generate inputs for contrastive learning: linear interpolation and non-linear interpolation, as shown in unified Figure 3. Both interpolation methods follow the same interpolation function [(4, B; X) defined as:
T(A, = = A-
where A and B are batch data representations, X [0, 1] denotes the interpolation index, and indicates wlement-wise multiplication. In CONTRABIN, we define H, T(H,, Hy: A)) and H, = I(H, H2; Xn) for linear and non-linear interpolation, respectively. Linear interpolation imitates the learning process between one thing to another, where the model progresses towards all knowledge points for a given task. In practice, we regard the interpolation index as a trainable parameter, learned by a neural network, denoted as:
A Finterp (H + H2),
(8)
7

---

Published in Transactions on Machine Learning Research (09/2025)
Manifold
Interpolation
Source Code
Inherent Similarity
hi
Binary
Inherent Disimiiaity
ha
Comment
Away from
M
Dissimilr Representation
Close
h'
Regresentation
Figure 4: Illustration of the intermediate contrastive learning. The source code h,, binary code hs, com- ment hes and their interpolations h, in manifold M are inherently similar, whereas they are dissimilar to any other program representations h' Therefore, they will be close one another but away from others during training.
where Finterp denotes the interpolation neural network function that learns the optimal interpolation index for H1 and H2, and X denotes a linear interpolation index ranging from 0 to 1. Note that the Interp NN blocks in Figure 3 are one of the possible implementations. We apply linear interpolation to the manifold vectors of source code and binary code using:
H = AI H1 + Xr) H2.
(9)
where H₁ denotes the batch-wise intermediate representation generated by the linear interpolation. The broadcast property is adopted so that the scalar A expands to the shape of Hi and H2, enabling element- wise multiplication.
Non-lincar interpolation for customized learning We further consider non-lincar interpolation to capture complex semantics and enhance model performance. Unlike linear interpolation, which uses a scalar X, non-linear interpolation treats the interpolation index as matrix with the same shape H1 and H2. allowing finer-grained and featuro-wise control. Formally, this is defined as:
An fm interp (H1 H2),
(10)
H = A, H1 + (1 (1-xxp) An) H2,
(11)
where An is a matrix representing the non-lincar interpolation index and finterp is the corresponding neural network function. Both interpolated embeddings H, and Hn serve as input to the intermediate rastivve
learning step.
Intermediate contrastive learning for representation refinement To further refine the binary code embeddings, introduce intermediate contrastive learning, which leverages interpolated representations generated in Subsection 2.2. These interpolations provide an alternative view of the program's 's semantics, acting as unseen yet reasonable information about the same program. This step builds on the concept of contrastive learning by incorporating these interpolated representations into the training process.
As illustrated in Figure 4, the interpolated reprosentation h; (a combination of source code projection h, and comment projection h₂) is compared against the binary code projection ha in the embedding manifold M. Similarly, h denotes all dissimilar projections, which include other representations in the batch that do not belong to the same program.
To compute the intermediate contrastive loss, we define
Σ
exp(sim(h;,h1)) N/)
MEB
8

---

Published in Transactions on Machine Learning Research (09/2025)
Algorithm CONTRABIN pre-training Iramework
Require: Source code set X, with paired binary code set No and comment set Xx, split into train X Xtrsin and validation X
Ensure:
Minimization of loss Xeal 1: if Primary contrastive learning then for batch I,..., Ratart do
3: Project Xe, X, and Xs to M with encoders fu and ft
Compute batch-wise similarity loss between two representations and train the predictors and encoder 5: end for
6: end
7: if Contrastive learning by linear non-linear simplex interpolation then
8: for batch = L,..,, kinterp do
Project X., X. and Xa to M with encoder fa and Choose two of the encoded representations and compute the index d or An by the interpolation NN and get intermediate representations
10:
11:
Compute batch-wise similarity loss between intermediate and the other representation in M and train the binary encoder and interp NN
12:
end for
13:
end
where B' denotes the set of all dissimilar projections in the batch, sim(;.) represents the cosine similarity between two embeddings, and is temperature parameter. The loss is then computed as:
1 N
exp(sim(h,, hb)/T) exp(sim(hs, ho)/T) + Zi
Lintermediate
log
where N is the batch size. This formulation encourages the interpolated representation h; to align closely with the corresponding binary code projection hg, while maintaining separation from unrelated projections N. By introducing Zí, we explicitly represent the normalization factor in the denominator, which simplifics the interpretation of the loss and enhances its clarity.
Intermediate Representations in Context Intermediate rastivetive learning refines embeddings by aligning related representations and separating unrelated ones, enabling CONTRABIN to better capture semantic relationships for improved learning.
To stabilize training, adopt stop-gradient mechanism for the anchored representation during opti- mization, detaching the gradient of h2 or he when used as the anchor to prevent instability caused by intermediate representations. This mechanism facilitates the integration of intermediate contrastive learning into the overall training process, ensuring that interpolated views contribute effectively to refining binary code embeddings. Building on this foundation, the subsequent gradual learning step further enhances the model's ability to capture nuanced semantic relationships across diverse program representations.
Gradual learning Following the gradual learning literature, models learn most effectively when they follow natural, progressive order humans do (Gou et al., 2021; Cho & Hariharan, 2019). Specifically, models learn high-level data abstracts initially, then progress to more complicated embeddings. Following this inluition, we train our model via primary contrastive learning during cold start. After several epochs (10 epochs in our implementation)) we switch the training pattern to contrastive learning based on linear simplex interpolation and non-linear simplex interpolation to further improve the generalizability of our model and finalize the training process, shown in Algorithm 1. By integrating all three parts, CONTRABIN follows a natural learning curve (i.e., from simple to complex) to better understand the meaning of binary code.

---

Published in Transactions on Machine Learning Research (09/2025)
Table 1: Categorization and objectives of downstream tasks.
Task
Domain
Objective
Algorithmic functionality classification (1)
Analysis
Calegorize binaries by functionality
Function name recovery (2)
Analysis
Predict meaningful function names
Code summarization (3)
Comprehension Comprehension
Generate concise summaries for binaries
Reverse engineering (4)
Decompile binaries into source code
2.3 Task-Specific Fine- Tuning
To evaluate the effectiveness of our pre-trained binary code embeddings, we apply them to four downstream tasks: (1) algorithmic functionality classification from binaries, (2) binary code function name recovery, (3) binary code summarization, and (4) binary reverse enginecring. These tasks compre- hensively span two domains: binary code analysis (tasks and 2) and binary code comprehension (tasks 3 and 4). By addressing a diverse set of challenges, our fine-tuning approach demonstrates the versatility and robustness of the learned embeddings.
Fine-tuning performed using specifc objectives, each tailored to the requirements of the respective downstream task. For classification tasks, including algorithmic functionality classification and function name recovery, employ cross-entropy loss function:
Lelassification
Ve log Di:
N
where is the true label, Di is the predicted probability, and N is the batch size. This objective encourages the model to predict accurate labels for binary code representations
For summarization and reverse engineering tasks, we treat the problem as a sequence-to-sequenec generation task. Here, the loss function used is a token-level cross-entropy loss:
N
T
Creq2eeq
1
Σ
Σ
yi. log H1.1,
N
where T represents the sequence length, Virr is the true token at time step 4, and hi. is the predicted probability for that token. This formulation ensures the model learns to generate accurate textual summaries and source code representations.
All four tasks are adapted from the CodeXGlue" benchmark, with modifications for binary code analysis. For instance, the binary functionality classification and function name recovery tasks are based on their corresponding tasks CodeXGlue but focus on pre-compiled binary representations rather than source code. Similarly, binary code summarization and reverse engineering extend the summarization and translation tasks in Coue to the domain of binary-to-nalural language and binary-to-source code transformations, respectively. Detailed descriptions for each task are provided below.
Algorithmic Functionality Classification from Binaries This task involves classifying binary code according to its functionality, such as distinguishing "quicksort" from "md5 hash." Accurate classification assists developers in isolating specific code blocks, improving readability, saving development time, and aiding in reverse engincering (Haq & Caballero, 2021). For example, given a binary, the goal to categorize into classes like sorting, hashing, or searching, As shown in Table 1, this task is categorized under 'Analysis' and represents key aspect of binary code analysis, where our method leverages multiple program representations for robust classification.
Function Name Recovery Recovering function names from binary code sequences is crucial for stripped binarics that lack meaningful names and debugging information. This task, categorized as "Analysis' in Table 1, significantly reduces manual effort in reverse engineering and ma malware analysis scenarios, particularly
httpps:/gittubb http:/hhtt..cceeetteeeeo//ooooat
10

---

Published in Transactions on Machine Learning Research (09/2025)
when source code is unavailable. By predicting function names effectively, our embeddings restore clarity to binary code, enhancing the overall analysis workflow.
Code Summarization This task translates binary code into concise English summaries, aiding compre- hension and facilitating security assessments, reverse engineering, and software maintenance. As outlined in Table 1, code summarization falls under the "Comprehension" category, emphasizing its role improv- ing understanding of binary functionality and enabling more effective software analysis through succinct summaries.
Reverse Engineering Decompiling binary code into source code is essential for tasks like security as- sessments, defect localization, and software comprehension. While tools like Hex-Rays and Ghidra offer decompilation support, they often generate code that lacks symbolic names and deviates from canonical developer written formats. Reverse engineering, classified under "Comprehension" Table 1, benefits from our embeddings by transforming binarics into more interpretable source code, providing valuable insights into the original binaries.
We summarize the categorization of these tasks, their objectives, and their respective focus areas in Table 1, which groups the tasks into 'Analysis' and 'Comprchension" domains.
2.4 Parallelism Between the Presented Steps and the Learning Stages
To ensure clear understanding of the connections between the training steps and the overall learning pipeline, explicitly describe the parallelism between the training stages and learning steps in CONTRABIN, Each stage in our framework directly contributes to specific aspect of the learning process, as illustrated in Figure? 2:
This step corresponds to the initial stage of representation learning, where naive interpolation (selecting a single representation from source code or comments) used. It serves the foundational phase to align binary code with these modalities in the embedding space without introducing intermediate representations.
Primary Contrastive Learning Step:
Secondary Contrastive Learning Step: This step builds upon the foundational alignment by introducing simplex interpolation, where representations source code and comments are interpo- lated to generate intermediate views. These interpolated representations provide a nuanced semantic bridge, which, when combined with intermediate contrastive learning, allows the model to refine its embedding space. By focusing on relationships between source code and comments, this step ensures that binary code embeddings are enriched through contextually meaningful relationships.
Task-Specific Fine-Tunin Tine-Tuning Step: In this final stage, the pre-trained embeddings are applied to downstream tasks. This step translates the learned embeddings into practical utility, demonstrating their effectiveness across binary analysis and comprehension tasks.
The transitions between these steps ensure seamless progression from foundational alignment to representa- tion refinement and practical application. This structured pipeline integrates the learning stages cohesively, as depicted in Figure 2 and aligned with the corresponding text sections.
3 Experimental Design
In this section, introduce the experimental design for the evaluation of CONTRABIN. Specifically, we design and conduct four experiments in total: one assessment of the pre-training of CONTRABIN, and three others for evaluating the performance of CONTRABIN's embeddings using indicative downstream tasks relating to binary code analysis. We introduce these experiments to answer the following research questions:
RQI: How accurately can the embeddings provided by CONTRABIN perform in the tasks of binary code analysis? Does CONTRABIN outperform state-of-the-art pre-trained language representation models evaluated by classification metrics?
11

---

Published in Transactions on Machine Learning Research (09/2025)
Frequency of programs vs. program length (log)
Binary length (log)
Comment length (log)
1.0
Source length (log)
Frequency of progams
0.8
0.6
0.4
0.2
0.0
Program length (log)
Figure 5: Length distribution of the source code, binary code, and comments in the preprocessed dataset. Comments are skewed to shorter lengths.
RQ2: How well do the embeddings provided by CONTRA BIN in the task of binary code comprehension? Is it better than state-of state-of-the-art pre-trained language representation models evaluated by NLP metrics and human perception?
RQ3: How effective is the linear and non-linear intermediate contrastive learning in CONTRABIN, and what are the advantages and areas for improvement?
Before we evaluate each RQ in turn, we first introduce the experimental configuration, including the dataset for training and evalution, as well as the experimental procedures and settings.
3.1 Training Design
To train CONTRABIN, we must build a dataset consisting of three program representations: source code, compiled binary code, and source code comments or summaries, and train CONTRA to generate improved embeddings for downstream tasks. We obtain each program representation as follows:
Source code: To obtain source code, use a widely-used public dataset called AnghaBench (Da Silva et al., 2021) as our source data for training CONTRABIN'. Specifically, we adopt the benchmark dataset that contains 1 million single-function C files extracted from programs and mined from popular GitHub repositorics. This dataset serves as the source code representation in our method to incorporate semantic variety into the training process.
Binary code: After obtaining the source code from AnghaBench, we compile the code snippets in Ang- haBench using Clang (specifically, LLVM*) to generate the corresponding assembly code. We choose LLVM assembly for platform transparency infrastructure supports many language backends from LLVM bitcode. However, in practice, any straight-line assembly language could fit the requirements of CONTRABIN (i.e., the contrastive learning framework).
many static and dynamic analyses exist for LLVM, and the Clang
During pre-analysis, we found most comments in real-world source code are not globally infor- mative. Specifically, human-written comments can be random in content (c.g., they may contain copyright notifications, random snippets of old code, or unstructured explanations), or contain partial information about the current location of code statements source code comments in general are not always descriptions of semantics of program's complete source code. Therefore, we adopt an Sncoder-Decoder To (Wang et al., 2021) model to automatically generate single comment for each snippet of source code in our dataset.
Comments:
4 AAnghaBench: wwt.:/dd.........bb///oo///oo home S.IVM Compiler Infrastructure: httpps// Mttps///.IMM..rrg.
12

---

Published in Transactions on Machine Learning Research (09/2025)
Figure 5 shows the length distribution of the processed dataset derived from AnghaBench. The overall com- ment length distribution is quite different from both source and binary code since comments are considered a high-level abstraction of information using natural languages (as opposed to structured programming or assembly languages). We also compute the 90th percentile of length and find the results for source code, binary code, and comments to be 422, 2853, and 63, respectively.
We use two Nvidia A40 GPUs during model pre-training and follow the parameter settings of Simple- CLIP (Shariatnia, 2021). We set the random seed as 42 in the pro-training for reproduction. To better evaluate the performance and robustness, we also train two versions of our model, CONTRABIN-PCA and CONTRABIN. For CONTRABIN-PCHI we set 10 epochs for primary contrastive learning only. For CONTRA- BIN, we use 10, 10, and 10 to improve the overall model efficiency on binary code analysis, and 10, 30, 30 to enhance the general model performance on binary code comprehension.
3.2 Evaluation Design
Our evaluation of each research question considers different tasks and perspectives. For each of our three downstream tasks, we choose a publicly available dataset (and corresponding reference in the literature). We preprocess each dataset so that they can leverage the pre-trained embeddings from CONTRABIN, The evaluation datasets include different source code and their compiled assembly. We describe each task and associated dataset in detail below.
POJ-104 For the binary functional algorithm classification task (RQI: Downstream Task 1), we adopt POJ-104 from the CodeXGLUE dataset (Lu et al., 2021). In an Open Judge (OJ) system, students submit their solutions to programming problem, and the OJ system judges whether the code can run successfully on all available test suites. In this way, the OJ system aims to improve the programming skills of users. From this dataset, we can find other programs that perform the same task as an input program (e.g., programs can be classified as bubble sort vs. heap sort. vs. Fibonacci sequence, etc.).
The dataset includes programming problems and verified source code solutions. There are 104 programming problems in POJ-104, with 500 examples each. The dataset is categorized into train/ http///eeeeee////////// /test sets with non-overlapping program problem labels. Thus, we can view this dataset as containing 104 different classes in which to classify an input program. While the original POJ-104 dataset used source code structural information, we adapt it for classifying input binaries.
In our experiments, we compile cach solution in POJ-104 to LLVM assembly code, koeping the functionality label unchanged, as shown in Table 2. This change transforms POJ-104 into an assembly code dataset suiting our binary analysis interests. We fine-tune each model with 2 epochs and block size of 400. We use training and validation batch sizes of 32 and 8, respectively, and choose learning rate to be 20-5 and maximal gradient normalization to be 1. In all fine-tuning processes, we use the default random seed of 123456.
DIRE For the binary function name recovery task (RQ2), we chose the DIRE dataset used to train DIRTY (Laeomass et al., 2019), a recent machine learning model augmenting decompiler outputs with variable type and name predictions. The full dataset contains around million functions spread across 75,656 binaries that were mined from public GitHub repositories using GHCC With the help of decompiler, each binary is lifted into equivalent C pseudocode and processed into a list of lexemes and an implementatioon-deinees format for emumcrating source-level variable information. Because the DIRE dataset is a preprocessed dataset that does not conform with CONTRABIN's expected inputs, we instead obtained the list of GitHub repositories that were used to construct the DIRE dataset and compiled each project ourselves. We modified GHCC to save the intermediate LLVM bitcode objects produced during compilation and disassemble each bitcode object into readable LLVM assembly using the LLVM disassembler.
In our experiments, we select function names with number of functions larger than 200, and remove some function names that are not specific to type of function (ie., main, and ___isst__e aist_add) to make sure the model is trained on meaningful data. We further strip all LLVM files of their original function names (i.e., @TESTFUNO as the name of the first function in an LLVM file) and measure CONTRABIN's ability to classify these function names. The dataset statistics are shown in Table 2. We fine-tune each model with
6GHCC hwt.s/ooocccco//eeeeeeeeee //hee
13

---

Published in Transactions on Machine Learning Research (09/2025)
Table 2: Dataset statistics for algorithmic classification.
POJ-104 (Punctionality Classification)
AnghaBench (Code Summarization)
Data Type
# Problems
# Examples
# Unique Sum
# Examples
Train
64
14,614
14,700
16,383
Dev
16
5,079
902
910
Test
24
8,102
890
911
DIRE (Function Name Recovery)
AnghaBench (Reverse Engineering)
Data Type
# Names
# Examples
# Unique Source
# Examples
Train
91
49,933
15,937
16,383
Dev
91
2,774
909
910
Test
2,775
903
911
epochs and a block size of 256. We use training and validation batch sizes of 8 and 16, respectively, and choose learning rate to be 2e-5 and maximal gradient normalization to be 1. In all fine-tuning processes, we use the default random seed as 123456.
AnghaBench For the binary code summarization and reverse engincering tasks, we use the AnghaBench test set (Da Silva et al., 2021) during pre-training, which includes code never been seen by the model. Specifically, we only select the main function in LLVM code and its paired source code for fine-tuning the code summarization and reverse engineering tasks. To better the capacity of pre-trained language models, we further truncate the length of binary code by only selecting the first 512 instructions. The datasct statistics displayed in Table 2. In this paper, we evaluate the model's ability to translate and summarize binary code using the validation set and analyze its embedding using the test set.
In our experiments, we defined the input length for both the summarization and reverse enginecring tasks as 512, and the output length for summarization ion and Iranslation as 32 and 512, respectively. We use training and evaluation batch size 16 and beam size of 5. We set the number of epochs for the summarization task to and the batch number for the reverse engineering task to 20000. For reproducibility, the random seed is set 42 for both tasks.
4 Experimental Results
In this section, we present the results of our evaluation, addressing each our research questions. We provide a detailed analysis of the data, discussing how supports or challenges our hypotheses. Specifically, we examine the effectiveness of our proposed approach in integrating binary code into large-scale pre-training models and incorporating rich information from source code and comments into binary code. We also evaluate the generalizability of our model across different downstream tasks in binary code analysis.
4.1 Embedding Analysis
We present a case study to analyze the binary code embeddings generated by our model. While binary codes the AnghaBench test set are unique, semantically related codes can naturally cluster together in the embedding space due to shared functionality or structural patterns. This clustering is an expected property of well-trained model and demonstrates its ability to encode meaningful relationships among binary codes. This analysis provides initial qualitative evaluation of the embedding behavior, offering insights into how our model encodes these relationships. While this analysis highlights trends in embedding quality, it is not intended to serve as definitive evidence, and we provide more robust quantitative evaluations in subsequent sections.
To ensure fair and dircct comparison, all bascline models presented in our evaluation were subjectod to the exact same fine-tuning protocol as CONTRABIN. This standardized procedure includes the use of the identical triplet dataset, data splits (training, validation, and test.), optimizer (AdamW), learning rate
14

---

Published in Transactions on Machine Learning Research (09/2025)
deftie Ioral recett Jeoapt Mt, 132-
leat (2D nooec. 13b
store 13 13, aloes
Mr ridee
stree
caeeti lecatt, knreeett resrea eehor preess Low Drymns, seneell
sill Koni,
A t-SNE visualization of binary code embeddings from the AnghaBench test set. Each plot shows the overall embedding space (blue dots) from different model. The highlighted red and orange dots represent two specific, semantically similar functions (process (process_record___eeeee to rllustrate semantic alignment. Baseline models like RoBERTa place these similar functions far apart and produce a scattered overall distribution. In contrast, both CONTRABIN (PCL) and the final CONTRABIN model cluster the similar functions closcly and organize the overall embodding space into more structured regions, demonstrating an improved ability to capture semantic relationships.
Figure 6:
and process serrass__eeord___s_eeee_ee
schedule, batch sizes, and early-stopping criterion. By maintaining a consistent experimental setup across all models, we can attribute performance differences primarily to the quality of the pre-trained embeddings themselves.
Case study: Semantic alignment of binary codes To evaluate the semantic alignment, selected two binary functions derived from process_record__ record_keymap and process process_record__.. record_user, which share similar input structures and functionality. As shown in Figure 6, embeddings generated by RoBERTa, CodeBERT, and GrRRRCodeBERT project these functions far apart in the embedding space. This separation indicates that these models struggle to capture the shared semantic characteristics the two functions. In contrast, embeddings generated by CONTRABIN (PCL) position the two functions closer logether, reflecting a better alignment their shared semantics. CONTRA BIN further reduces the distance between these functions, demonstrating its ability to refine binary code embeddings through intermediate contrastive learning.
General trends in embedding space structure To analyze how different models organize binary codes in the embedding space, we examined patterns across the AnghaBench test set. Figure 6 illustrates that em- beddings generated by RoBERTa, CodeBERT, and GraphCodeBERT exhibit scattered distributions, with no discernible grouping for binary codes derived from similar tasks, such as hash table operations or data processing routines. Tn contrast, embeddings from CONTRABIN (PCT.) display a more structured distribu- tion, where binary codes related to similar functionalities begin to cluster into distinct regions. Embeddings generated by CONTRABIN refine this structure further, consolidating these clusters into cohesive region while maintaining separation for unrelated binary codes. This visualization reveals distinct patterns in how the embedding spaces produced by different models are structured, offering insights into the organization of binary code representations.
Our evaluation protocol for all downstream tasks strictly adheres to the standards set by the official CodeXGlue benchmark. This includes the mandated use of its specified default random seed of 123456 for all experiments. This decision is crucial for ensuring that our results are fully reproducible and maintain direct comparability with the established body of work evaluated this framework.
15

---

Published in Transactions on Machine Learning Research (09/2025)
Quantitative evaluation of CONTRABIN on binary functional algorithm classification of POJ104 using mean of average precision (MAP), recall (MAR) and F1 score (MAF1).
Table 3:
Approaches
MAP
MAR
MAF1
RoBERTa (Liu et al., 2019)
38.29
28.57
32.72
CodeBERT (Feng et al., 2020)
39.99 (+4.44%)
29.94 (+4.80%%
34.24 (+4.64%)
GraphCodeBBRRT (Guo et al., 2020)
39.48 (+3.11%)
29.38 (+2.95%)
33.69 (+2.96%)
CONTRABIN (PCL)) CONTRABIN (Ours)
37.03 (-3.29%
26.99 (-5.53%)
31.22 (-4.59%)
43.78 (+14.34%)
33.87 (+18.55%)
38.19 (+16.71%)
Table 4: Quantitative evaluation of CONTRABIN and multiple pre-trained methods on binary function name recovery of DIRE using accuracy, mean of average precision (MAP), mean of average recall (MAR), and mean of average F1 score (MAF) as four key criteria.
Approuches
Accuracy
MAP
MAR
MAF1
RoBERTa (Liu et al., 2019)
29.41
28.41
25.00
26.59
CodeBERT (Feng et al., 2020)
24.94 (-15.20%)
23:25 (-18.13%)
20.82 (-16.70%)
21.97 (-17.39%)
GraphCodeBERT (Guo et al., 2020)
25.95 (-11.76%)
27.59 (-2.87%)
22.52 (-9.91%)
24.80 (-6.74%)
CONTRA BIN (PCL) CONTRABIN (Ours)
28.83 (-1.96%)
28.65 (-0.85%)
25.83 (-3.35%)
27.17 (-2.16%)
33.41 (+ (313.60%)
30.79 (+8.33%%
28.14
(+ (2.55)8)
29.41 (+10.58%)
4.2 RQ1: Binary Code Analysis
After analyzing embedding of binary code using all pre-trained models, we start qualitative binary code anal- ysis of CONTRABIN by two downstream tasks: algorithmic functionality classification and binary functiona name recovery.
Result for POJ-104 Our first downstream task is algorithmic functionality classification for binary code. Recall that, in this setting, we use pre-trained embeddings from CONTRABIN to aid classifying an input binary snippet into one of 104 classes of algorithms (e.g., bubble sort vs. heap sort vs. Fibonacci, etc.).
To evaluate the performance of CONTRABIN in this downstream task, we adopt mean of average preci- sion (MAP), mean of average recall (MAR), and mean of average F1 score (MAF) as three key criteria. We consider only C code that can be compiled to binaries - while most programs compiled successfully, we exclude those that could not be compiled, and report MAP, MAR, and MAF across all 104 classes. For this task and the three subsequent tasks, we used the results of RoBERTa as a bascline for comparison.
Table 3 presents the quantitative evaluation of CONTRABIN against several pre-trained methods. CodeBERT and Cod shows comparable performance to RoBERTa on all three metrics, with a performance improvement of less than 5%. However, CONTRABIN demonstrates a substantial improvement in MAP, MAR, and MAF1 by 14.34%, 18.55%, and 16.71%, respectively. We note that the performance of CON- TRABIN (PCL) is lower than that of RoBERIa. This can be partially attributed to the use of contrastive learning over three different modalities, which can result in the binary code embedding becoming overfitted to the exact embedding of either source code or comments, making the model less effective.
Result for DIRE Our second task for binary code analysis is function name recovery, which is transformed into a function name classification task where the models are required to classify binary code into one of the 91 function names based the settings. To evaluate the model performance, we used the same metric set as in POJ-104, with an additional accuracy metric, and applied all models to compiled LLVM code of the DIRE dataset.
The overall performance, as shown in Table 4, revealed that fine-tuning CodeBERT and GraphCodeBERT resulted in a docrease in performance, making them less effective than the bascline RoBERTa model in all metrics by up to approximately 20%. This demonstrated that current models are unable to generalize when the domain of downstream applications for binary code analysis shifts and may even become ineffective. On
16

---

Published in Transactions on Machine Learning Research (09/2025)
Table 5: Quantitative evaluation of CONTRABIN and multiple pre-trained methods on binary code sun- marization of AnghaBench using BLEU-4, GLEU-4, ROUGE-2, and exact match (xMatch). Performance differences are calculated relative to GraphCodeBERR.
Approaches
BLEU-4
GLEU-4
ROUGE-2
xMatch
RoBERTa (Liu ct al., 2019)
24.30 (-25.05%)
25.55
(-22445%)
30.16 (-23.52%)
4.95 -37.419%)
CodeBERT (Feng et al., 2020)
32.07 (-1.11%)
32.80 (-0.13%)
38 38.83 (-1.57%)
7.91 (0.00%)
GraphCodeHERI (Guo al,, 2020)
32.43 (Rase)
32.94 (Base)
39.45 (Base)
7.91 (Base)
CONTRABIN (PCL)
30.89 (-1.75%)
31.13
(-5.00%)
37 02 (-6.15%)
6.70 (-15.28%)
CONTRABIN (Ours)
34.36 (+5.95%)
34.82 82 (+5.71%)
41.20 (+4.439))
9.34 (+18.10%)
Unloads rutex
atatas read dectityy
detine internal uaid desemeelan anttoall cell
Contrnditin: Unleace nutes
asonulariiy www.oeeeeaae
Lade BeAL lock!
ContoainNPALL triceds
Gropicodeeeti Uniloees the natex
cofine docal L22 anstmainii3 132, 92, alion load uste call bow.iii 54,
Returns constant that is used for the object
goven
Costratant Nal1 This furction sase to cotans typodat (spodal for Uhe Uppaee for th
lead 132, 1it so, alton gut_config_stn, alige
Ir label 63
retertal acturns the mamer of tytte the giver statform cosobert: This fucction definee the varisales funetion grapheadenerts
2: preds 26, N1
rat 232 92
fuxctions
Figure 7: A positive case study on binary code summarization. The first case demonstrates CONTRABIN's ability for semantic completion, while the second showcases its long-term semantic reconstruction capability,
the other hand, CONTRABIN still demonstrated considerable improvement over all three metrics by 13.6%, 8.39%, and 10.58, respectively, demonstrating the generalizability of our pretrained model on different downstream tasks.
4.3 RQ2: Binary Code Comprehension
We further analyze CONTRABIN's ability in binary code comprehension by evaluating its performance on two additional downstream tasks: binary code summarization and binary code reverse engineering. We used the test set of AnghaBench to perform in-domain analysis to assess the effectiveness of our proposed approach.
Result for AnghaBench (Summarization) For the binary code summarization task, we evaluate all models using four widely adopted metrics: BLEU-4 (Papineni et al., 2002), GLEU-4 (Mutton al., 2007), ROUGE-2 (Lin, 2004), and Exact Match (xMatch). As shown in Table 5, CONTRABIN achieves consistent improvements across all metrics compared to the baseline method, GraphCodeBERT. Specifically, CON- TRABIN shows improvements of 5.95% in BLEU-4, 5.71% in GLEU-4, 4.43% in ROUGE-2, and 18.08% in xMatch over GraphCodeBBERT, showcasing its superior capability in binary code summarization.
Table 6: Quantitative evaluation of CONTRABIN on binary reverse engineering of AnghaBench using BLEU- 4, GLEU-4 and exact match (xMatch).
Approaches
BLEU-4
GLEU-1
xMatch
RoBERTa (Liu et al., 2019)
69.72
68.29
23.52
CodeBERT (Feng et al., 2020)
70.37 (+0.94%)
67.27 (-1.0%%
23.41 (-0.47%)
GraphCodeBERT (Guo et al., 2020)
71.56
(+2.64%)
69.88 (+2.32%)
24.73 (45.149%)
CONTRABIN (PCL)
69.73
(+0.02%)
69.41
(+1.64%)
23.41 (-0.47%)
CONTRABIN (Ours)
71.14 (+2.04%)
70.41 (+3.10%)
25.16 (+7.01%)
17

---

Published in Transactions on Machine Learning Research (09/2025)
boott sys eat prouthhere aa aayeit_aaepstttaa oc
Gold
refur roger afree Tiaclly raary terypr socippor taan, Taas, (a00))
prosecist sa:
defire sttstt-cntoitttiste @rypts_alle,sccittrii w. 122 allecs 1it 01391
12 sffece 132, slagn
<tow u.
4
le allees 13t ullgt 4
122- 8o. alige
(105 381, 136 281 Q-str, Jse 6, 104 Ei 133 sol
stare 122
Mr, 17t All
16
16 lued (S0 (Sv M5 41:91
call 112
132, 122- 92; aldge
Strert..rypmm4400 (6ijttts Strpia Mtilie to, Beysto.hccteeroooo
cor 197
Cortiniis
// Cant-vtton
twt.eitt. att_aresttie crareet and.-aneeeteerr adstanl; wi groasteratus
I/ CoeeeEt ast.eitt.nee arsugatttt
sinst syttthcater worapta ailattaailacaaaaaa kcuterr forat ther (ys,, neact oryer biy Genper
Tyon,
ca wit aowreiti
costritiiess
anpttu decaper aomptaaalias dicaberion the sale, Type, u sapued corpttchhuperrbbg bps,
East saanirtt
7/ steeaaet
Issom
okclater then ratur topertatiee, sae, coypetytccheerrre type, soutt, count)
kveats
cre greapt smaces
at onptoaat sorptouation poppttuttissaaee aicatte lorat the way, matio seatll
prsotooii retersigtss:::
tranceesann
af cnett allec renur tojerLatien_ Hitteer Soype/Arraee... len, Sacki
earth, maakl
Figure 8: A positive case study on binary reverse engineering. The first case demonstrates CONTRABIN's ability to control generated content, while the second showcases its ability to maintain semantic consistency,
To further highlight the effectiveness of CONTRABIN, we present a case study in Figure 7. In the first example, CONTRABIN successfully captures the functionality of the binary program, while other models diverge to irrelevant objectives, such as 'cpu,' 'file," or "lock." In the second example, other models struggle with summarizing longer binary code. For instance, CONTRABIN (PCL) generates incomplete sentences, whereas RoBERTa, CodeBERT, and GraphCodeBERT produce either incorrect or overly general summaries. These cases demonstrate CONTRABIN's ability to maintain long-term semantic consistency and robustness in binary code summarization, enabled by its novel binary embeddings.
Result for AnghaBench (Reverse Engineering) For the binary code reverse engineering task, we use similar metries, except ROUGE, which is designed for summarization only, to evaluate the performance of CONTRABIN on direct code translation between source code and binary code. As shown in Table 6, CON improves the baseline method by 2.04% in BLEU, 3.10% in GLEU, and 7.01% in xMatch. Compared with GrapHCodeBERII, which outperforms CONTRABIN in BLEU, CONTRABIN outperforms on the other two metrics (GLEU and xMatch).
We also show a case study in Figure& 8. In the first case, CONTRABIN can maintain the consistency of variable names in the generated source code, while the other methods have issues such as changing variable names and adding incorrect statements. In the second case, the other methods also generate more redundant information. This highlights the ability of CONTRABIN to generate semantically consistent binary code translations.
4.4 RQ3: Analysis and Summary of Model
We can evaluate the effectiveness of different components of CONTRABIN through the performance of CON- TRABIN (PCL). Our novel model component improves the quality of binary code embedding, as evidenced by our embedding analysis. Our proposed intermediate contrastive learning improves model performance and enhances the robustness and generalizability of the model across various downstream tasks in binary code analysis, as demonstrated by tasks 1 and 2. Furthermore, CONTRABIN can accurately summarize and translate more binary code while maintaining semantic consistency and long-term dependent coverage, as indicated by tasks 3 and 4. Demonstrated by all four downstream tasks, including two tasks for binary code analysis and two tasks for binary code comprehension, we can confidently conclude that CONTRA- BIN enhances the quality of binary code embeddings, leading to improved model performance and greater generalizability.
18

---

Published in Transactions on Machine Learning Research (09/2025)
Table 7: Ablation studies of CONTRABIN on binary functional algorithm classification of POJ104. We report mean average precision (MAP), mean average recall (MAR), and mean average F1 score (MAF1). Absolute scores are shown, with differences from the full CONTRABIN baseline reported in parentheses (pt). Note: Human-written comments provide minimal discriminative signal, resulting in very low absolute performance.
Ablation Variant
MAP
MAR
MAF1
Iumann-rritee comments
3.11 (-40.67) 3.01 (-30.86) 3.06 (-35.13)
Comment removal
42.76 (-1.02)
33.23 (-0.64)
37.40 (-0.79)
Auchor removal
40.96 (-2.82)
31.07
(-2.80)
35.34 (-2.85)
Interpolation removal
37.03 (-6.75) 26.99
(-6.88) 31.22 (-6.97)
CONTRA BIN (Full model)
43.78
33.87
38.19
5 Ablation Studies and Model Insights
In this section, we delve into the critical components of our model through extensive ablation studies and comparisons, demonstrating the impact of each design choice the overall performance. Additionally, we explore the adaptation of our model architecture to contemporary LLMs, particularly the transition from RoBERTa to T5, and how our pretraining strategy enhances the model's understanding of binary code. The findings underscore the importance of cach element in our approach and validate the effectiveness of our training methodology.
5.1 Ablation Studies
We assess each component of our model through ablation studies. Specifically, we remove three conditions test the efficiency of each design element: (1) We remove comments one of the modalities during training, (2) we replace the anchored encoder with learnable eliminate both linear and non-linear interpolation from our model design. For the pretraining process, we adhere to the original hyperparameters, training the first and second ablations for 30 epochs and the third ablation for 10 epochs. For the third ablation, we ensure that the model is converged by the end of pretraining. We test the pretrained models on the binary functional algorithm classification of POJ-104, using the same hyperparameters. The results are shown in Table
that it can be updated during training, and (3)
From the table, it is evident. that removing comments, stopping gradients, and eliminating interpolation decrease the MAF1 scores by 2.07 pt, 7.46 pt, and 18.25 pt, respectively. This demonstrates the effectiveness of each component in our model design. The baseline performance observed in these ablation studies is follows: MAP of 43.78, MAR of 33.87, and MAF1 of 38.19. We will use these baseline performance metrics as reference in the following sub-analysis to further dissect the contributions of individual components.
5.2 Comparison of Kluman-Writter and LLM-Generated Comments Pretraining
In our study, we explored the impact of using human- versus LLM-generated comments during the pretraining phase of CONTRABIN. The objective was to evaluate how each type of comment influences the model's ability to comprehend and process binary codc. While human-written comments provide diverse range of insights, they are often inconsistent in length and detail, which may limit their effectiveness in large-scale pretraining scenarios. On the other hand, LLM-generated comments tend to be more consistent and focused, potentially offering more structured learning experience for the model. The following analysis compares the length distributions and performance outcomes associated with both types of comments.
Comment length distribution analysis The analysis of comment length distributions, as depicted in Figure 9, reveals a significant. difference between human-written and LLM-generated comments. Human- written comments display a broader spread and variability in length, suggesting diverse approaches to code documentation by developers. On the other hand, L.M-generated comments tend to be shorter and more
19

---

Published in Transactions on Machine Learning Research (09/2025)
Comparison of Comment Lengths (log)
Length (leg)
1.4
Human-Written Comment Length (log)
1.2
1.0
Frequency
0.8
0.4
0.2
0.0
Comment length (log)
Figure 9: Comparison of log-transformed length distributions for original and extracted comments. The hunan-written comments exhibit broader spread indicating diverse lengths, whereas generated comments are predominantly shorter.
consistent in length, indicating comment length and variability may impact the pretraining effectiveness of CONTRABIN. To explore this further, we conducted a series of experiments to compare the performance of CONTRABIN when pre-trained using mumtnewritten versus LLM-generated comments.
standardized generation process by the model. These distinctions in
Performance comparison The experiments reveal striking docrease performance when CONTRABIN is trained with human-written comments compared to LLM-generated comments. Specifically, Table 7 shows that the use of human-written comments results in MAP dropping from 43.78 to 3.11, MAR from 33.87 to 3.01, and MAFI from 38.19 to 3.06. These reductions of 40.67 pt, 30.86 pt, and 35.13 pt, respectively, highlight the stark contrast in effectiveness between the two types of comments.
The collapse in performance with human-written comments underscores the critical role of concise and consistent LLM-generated comments in enhancing CONTRABIN's ability to comprehend and analyze binary code. thmma--rritten comments often introduce noise or inconsistencies that hinder representation learning, while the structured nature of --M-eenertted comments provides stronger foundation for binary code analysis. The performance gap be attributed the following factors:
Redundancy and Verbosity: written comments often include excessive or rodundant details, introducing noise that disrupts semantic aligument between source code, comments, and binary code.
Focus Implementation Details: Unlike LLM- ALM-generated comments, human- comments tend to emphasize specific implementation nuances rather than summarizing the core functionality, which impairs generalizable learning.
Variability in Style and Structure: Human-written comments exhibit inconsistent styles and structures, creating additional challenges for coherent learning compared to the uniformity of LLM- generated comments.
These findings emphasize the necessity of concise, high-level comments for effective representation learning and highlight the critical impact of training data quality on model performance. Future work should fur- ther investigate the interplay between comment quality and model effectiveness to better understand these dynamics.
20

---

Published in Transactions on Machine Learning Research (09/2025)
5.3 Multi-Ster vs. Multi-Objective Pretraining Approaches
We further explore the impact of different pretraining strategies on the performance of our model. Specifically, we compare the effectiveness of traditional multi-step pretraining approach with a more integrated multi- objective contrastive learning method. By analyzing these approaches, we aim to understand how the alignment and combination of multiple objectives influence the model's ability to classify binary functional algorithms accurately.
Multi-Objective Contrastive Learning: In this study, we introduced a multi-objective contrastive learn- ing approach that incorporates an average of all three a unified multi-objective loss function. This method was designed to encourage the model to simultane- ously learn from all available modalities, aiming to enhance its overall ability to classify binary functional algorithms.
code, source code, and comments- as
Performance Comparison: The performance results highlight dramatic decrease in effectiveness when transitioning from multi-step pretraining approach to a multi-objective contrastive learning method. Specif- ically, the multi-objective approach led to a reduction of over 97% across all key metrics MAP, MAR, and MAF1 MAFI-compared to the multi-stop method. This stark drop underscores the difficultics and risks associated with integrating multiple objectives inlo a single learning process, particularly when these objectives are not perfectly aligned or when the model struggles balance the competing losses effectively.
5.4 Negative Cases
In this negative case study, we examine a scenario involving function classification in binary code, as illus- trated in Figure 10. The original function is a simple program that reads an input, performs a sequence of operations, and prints the result. The code is structured in a way that preserves the flow of data from the input through various function calls to the output. This structure is essential for maintaining the logical integrity of the program, any deviation in the sequence or function calls could alter the intended behavior.
CodeT5's Performance Code'T5 successfully identifies and preserves this structure, correctly mapping the sequence of operations from the source code to the binary function. By doing so, CodeT5 ensures that the original intent the program is maintained in the binary output, demonstrating its ability to handle the intricacies of binary code classification where functional integrity paramount.
ContraBin's Misclassification In contrast, CONTRABIN misclassifies the function, likely due its ex- tensive pretraining on natural language and source code semanties. While CONTRABIN's broad pretraining allows it to capture a rich set of semantic relationships, this can lead to overgeneration or misinterpretation when applied to binary code, where precise structural alignment is critical. The model's reliance on seman- tic cues from source code and comments may introduce biases, causing it to incorrectly infer the function's 's structure, as seen in this case. This misclassification highlights a potential limitation of CONTRABIN's ap- proach: while it excels in tasks requiring semantic understanding, it may struggle scenarios where the strict preservation of code structure necessary for accurate function classification.
5.5 Extensibility to Contemporary LLMs
The evolving landscape of I.I.Ms necessitates the adaptation of existing methodologies newer, more ad- vanced architectures. As LLMs like T5 (Raffel et al., 2020), CodcT5 (Wang et al., 2021) and its deriva- lives become increasingly prominent, it is crucial to ensure that techniques initially developed for models like RoBERTa can be effectively extended to these contemporary frameworks. This section outlines the key adaptations required to transition from RoBERTa's encoder-only architecture to T5's encoder-decoder structure.
Model Architecture Adaptation: Adapting from RoBERTa to T5 requires handling the transition from an encoder-only architecture to an encoder-docoder framework. This involves modifying the model structure to ensure that the input is properly processed through both the encoder and decoder layers of T5. Specifically, tasks previously handled by RoBERTa's 's single encoder must now be split.
21

---

Published in Transactions on Machine Learning Research (09/2025)
Pinclude <stdio.h>
#include <stdio.h-
int read(2;
=stdio.
int ritant int b2: vold print resultts
vois foot);
vold print(l:
void work(int vari;
int rain()
int rain()
int main() {
var2 0:
int vari 95
var3:
readf];
int var2;
Svardl;; print (resulti; return
fool); print(l; return
scanf(" 6var2]; work( return
Original Function
Choice CodeTS
Chosce ContraBin
@ssini) 132x M1, align 52 call 132 gread]) call void grool) call vo (print() ret 132
grain() alloce alagn
deo,
define dso local 132 pewin(] 60 $1 alloca 132, alian 10
61 alloca store
alloca 182, all
store 132x 53, wlign w4 load 192, 137- 10, align call void Swork1132 541 rot 132
store 132 132x M1, align N3 alloca 132, align
align 152 15)
56 call 192
call void @print 46)
ret 132 8
Figure 10: A negative case study on POJ function classification in binary code. The second example shows CodeT5's s success in maintaining functional integrity, while the third example highlights a misclassification by ContraBin, which overfit to the source and comment information due to contrastive lcarning.
Table 8: Performance Comparison of CONTRABIN and CodeT5 with T5 on Binary Functional Algorithm Classification for POJ104 (MAP, MAR, MAF1).
Model
MAP
MAR
MAF1
T5 (Raffel et al., 2020) 28.82 (+23.42%)
23.35
17.34
19.90
CodeT5 (Wang al., 2021)
21.71 (+25.211)
24.76 (+24443%))
CONTRABIN (CodeT5)
30.1 (+28.91%)
22.16 (427.79%)
25.53 (4-2.341%)
between T5's encoder and decoder to fully leverage T5's capacity for generating meaningful output sequences.
Tokenizer and Data Processing: The transition also involves switching from RoBERTa's Byte- Pair Encoding (BPE) lokenizer to T5's SentencePiece tokenizer. This change necessilates revisiting the data preprocessing steps to accommodate the differences in how tokens are generated, including adjustments in token length, padding, and special token handling to ensure compatibility with T5's tokenization requirements.
Attention Mechanisms and Loss Function: The difference in attention mechanisms between RoBERTa and T5 requires revising the attention computation, especially in the forward pass. Addi- tionally, because T5 is designed for sequence-to-sequence tasks, the loss function and output processing need adjust to align with T5's architecture, ensuring that the model optimizes elfectively during training.
For this task, we utilized Nvidia A100 GPUs for CONTRABIN (CodeT5) model pre-training, with the random seed set to 42 to ensure reproducibility. Since the focus was exclusively on binary code analysis rather than comprehension, we adjusted our training strategy accordingly. We roduced the training duration to 40% of the previous rounds to concentrate the model's efforts on this specifie task. This reduction intentionally implemented to optimize the model's performance in binary code analysis, ensuring precision and efficiency without unnecessary overextension.
As shown in Table 8, the CONTRABIN (CodeT5) model with our pretraining method achieves significant improvements over CodeT5, Specifically, our model achieves a MAP 30.1, which a 4.45% improvement over CodeT5, a MAR of 22.16 (+2.07%), and a MAF1 of 25.53 (+3.11%). These results underscore the effectiveness of our training methodology in enhancing the model's ability comprehend and process binary code, demonstrating the adaptability and strength of the T5 architecture.
22

---

Published in Transactions on Machine Learning Research (09/2025)
By addressing the challenges in model architecture, tokenization, and attention mechanisms, we have demon- strated how our approach not only maintains but also enhances its effectiveness in processing binary code across different LLM architectures. This adaptability underscores the flexibility and robustness of our methodology, particularly when applied to state-of-the-art modcls like T5.
6 Related Work
In this section, we highlight key areas of related work, including traditional program analysis techniques and neural models for binary code analysis. Additionally, we discuss the foundational concepts that inspired the design of CONTRABIN, such as large-scale pre-trained embeddings, simplex interpolation, contrastive learning, and graph representation learning. These areas provide strong basis for understanding how CONTRABIN leverages advancements in program analysis and machine learning to improve binary code representation and comprehension.
Binary code analysis Binary code analysis plays an important role the bigger domain of software analysis and maintenance. For example, tracing exccution can help the analysis of the functionality algorithms from binaries (Pierce & Mudge, 1994), reusing profile information can speed up the similarity comparison of frequently executed core code (Wang et al., 2000), incorporating sequences of system calls can help detect software vulnerabilities (Giffin et al., 2004), and combining machine and binary-interface descriptions can assist software reverse engineering (Cifuentes et al., 1999). Traditionally, in programming language and software engineering, researchers have presented various work based on static and dynamic program analysis techniques. For instance, BYTEWEIGHT (Bao et al., 2014) automatically classifies algorithms by functionality from binarics, BINSEC (Djoudi & Bardin, 2015; David et al., 2016) formalizes low-level regions of code to extract semantics on the programs, and BinSide (Aslanyan et al., 2020) uses intermediate representations to conduct cross- ploss-plaffom static analysis.
Neural code models In recent years, neural code models have attracted the attention of researchers in software engineering and security. With the assistance of AI (Vaswani el al., 2017), it can improve many source code analysis tasks, such as neural clone detection, neural code similarity comparison, neural code search, etc (Ben-Nun et al., 2018; Shi et al., 2019; Zeng et al., 2021; Ye et al., 2020; Zhang et al., 2022).
For example, SySeVR combines syntax, semantics, and neural vector representation to detect software vul- nerabilities (Li et al., 2021), InnerEye adopts techniques in Natural Language Processing (NLP) to compare between samples of binary code (Zuo et al., 2019), GNN-BPE (Guo et al., 2022b) applies Graph Neu- ral Networks (GNN) on binary code by fusing the semantics of Control Flow Graphs (CFG), Data Flow Graphs (DFG), and call graphs, and Bin2Vec (Arakelyan et al., 2021) learns binary code representation via Graph Convolutional Networks (GCN). Compiler chain detection has also emerged as a promising application of machine learning in binary analysis, enabling the identification of the toolchains used to generate binary executables and aiding tasks like provenance analysis and malware detection (Chen et al., 2022a; De Blaere et al., 2023). Additionally, the survey by Marcolli et al. (Marcelli et al., 2022) provides detailed review of how machine learning techniques are solving the binary function similarity problem, which complements the above-discussed approaches. However, these methods involve complex aggregation of additional binary code representations and have limited generalizability across tasks.
Large-scale pre-trained embeddings With the recent success of large-scale pre-trained embedding in AI, research has been conducted on applying similar approaches to code analysis (Ben-Nun et al., 2018; Shi et al., 2022; Jiang et al., 2022; Bertolotti & Cazzola, 2022). In particular, RoBERTs (Liu et al., 2019) serves as the baseline, CodeBERT (Feng et al., 2020) incorporate code generation and identification into training process, GraphCodeBERT (Guo et al., 2020) combines Abstract Syntax Tree (AST) to further improve embedding quality. There are also many recent models designed for source code understanding. including CodeTrans (Elnaggar el al., 2021) and CoTexT (Phan et al., 2021) that incorporate different language modalities and multi sub-tasks for better code representation learning, and CodeT5 (Wang et al., 2021) which proposes an identifier-aware pre-training task to improve embedding distinction. CONTRABIN aims similar goals with these large-scale language representation models but focuses on a more effective and efficient representation for binary code in terms of better semantics
23

---

Published in Transactions on Machine Learning Research (09/2025)
Contrastive learning As recent emerging research direction, contrastive learning enhance the per- formance of many computer vision tasks by contrasting samples against each other to learn common proper- ties (Tian et al., 2020; Xiao et al., 2020). For example, MoCo (He et al., 2020) proposes dynamic dictionary to facilitate contrastive learning, SimSiam (Chen & He, 2021) introduces a Siamese network and stop gradient scheme to prevent collapsing in optimization, and CLIP (Radford et al., 2021) integrates visual concepts and raw text about images to provide much broader source of supervision multi-modal contrastive learning. As for program understanding, ContraCode (Jain & Jain, 2021) the first work using contrastive learning in source code analysis by code angmentation and comparison. We design CONTRABIN based the con- trastive learning framework which simultancously and gradually learns from binary code, source code, and comments within the same program.
7 Conclusion
To summarize, we propose a novel approach that fully integrates binary code into the large-scale pre-training model framework and incorporates rich information from source code and comments into binary code. Our experiments demonstrate that our proposed components outperform other approaches in four downstream lasks in binary code analysis and comprehension. We believe that our research work can inspire the AI, software engineering, and security communities to develop new methods that can further improve binary code analysis and comprchension and facilitate binary code applications from various perspoctives.
Data Availability Statement
The data and code used in this study publicly available Zenodo at 5219264. The repository includes:
Preprocessed datasets used for training and evaluation.
Complete implementation of the CONTRABIN framework, including all scripts for data preproccssing, model training, and evaluation.
Detailed documentation and configuration files to facilitate reproducibility and case of use.
Researchers are encouraged to access the repository to replicate our findings or use the provided resources as foundation for further studies. Any questions or issues regarding the data or code can be directed to the corresponding hors.rs.
References
Shushan Arakelyan, Sima Arasteh, Christophe Hauser, Erik Kline, and Aram Galstyan. Bin2vec: learning representations of binary executable programs for security tasks. Cybersecurily, 4(1):1 14, 2021.
Hayk Aslanyan, Mariam Arutunian, Grigor Keropyan, Shamil Kurmangaleev, and Vahagn Vardanyan. Bin- side: Static analysis framework for defects detection in binary code. In 2020 Ivannikov Memorial Workshop (IVMEM), pp. 3-8. IEEE, 2020.
Tiffany Bao, Jonathan Burket, Maverick Woo, Rafacl Turner, and David Brumley. (BYTEWEIGHT): Learning to recognize functions in binary code. In 23rd USENIX Securily Symposium (USENIX Securily 14), pp. 845-860, 2014.
Tal Ben-Nun, Alice Shoshana Jakobovits, and Torsten Hoefter. Neural code comprehension: A learnable representation of code semantics. Advances in Neural Information Processing Systems, 31, 2018.
Francesco Bertolotti and Walter Cazzola. Fold2vec: Towards statement based representation of code for code comprehension. ACM Transactions on Software Engineering and Methodology, 2022.
24

---

Published in Transactions on Machine Learning Research (09/2025)
Ligeng Chen, Zhongling He, Hao Wu, Fengyuan Xu, Yi Qian, and Bing Mao. Dicomp: Lightweight data- driven inference of binary compiler provenance with high accuracy. In 2022 IEFE International Conference on Software Analysis, Evolution and Reengineering (SANER), pp. 112 122. IEEE, 2022a.
Qibin Chen, Jeremy Lacomis, Edward J. Schwartz, Claire Le Goues, Graham Neubig, and Bogdan Vasilescu. Augmenting decompiler output with learned variable names and types. In 31st USENIX Security Sympo- sium, Boston, MA, August 2022b. URL https: //wp:://www.. http://wwww.u.ix...////// usenix. useenx.org//eeeeeeeeeooeee. www.ooog//oooo.oooooooooooooo. /ttp///orrneeeeeenaaccrrrrttoa/t
sentation/chest cheaatiiionceenqiiiin
Xinlei Chen and Kaiming He. Exploring simple siamese representation learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pottern Recognition, pp. 33750-15755 2021.
Jang Hyun Cho and Bharath Hariharan. On the efficacy of knowledge distillation. In Proceedings of the IEEE/CVF international conference on computer vision, pp. 4794-4802, 2019.
Cristina Cifuentes, Mike Van Emmerik, and Norman Ramsey. The design of a resourceable and relargetable binary translator. In Sirth Working Conference Reverse Engineering (Cot. No. PR00303), pp. 280 291. IEEE, 1999.
Gabriella Contardo, Ludovic Denoyer, and Thierry Artières. Representation learning for cold-start recom- mendation. In JCLR, 2014.
Anderson Faustino Da Silva, Bruno Conde Kind, José Wesley de Souza Magalhães, Jerônimo Nunes Rocha, Breno Campos Ferreira Guimaraes, and Fernando Magno Quinão Pereira. Anghabench: A suite with one million compilable с benchmarks for code-size reduction. In 2021 IEEE/ACM International Symposium on Code Generation and Optimization (CGO), pp. 378-390. IEEE, 2021.
Robin David, Sébastien Bardin, Thanh Dinh Ta, Laurent. Mounier, Josselin Feist,, Marie-Taure Potet, and Jean- Marion. Binsec/se: A dynamic symbolic execution toolkit for binary-level analysis. In 2016 IEEE 23rd International Conference on Software Analysis, Evolution, and Reengineering (SANER), vol- wme 1, pp. 653-656. IEEE, 2016.
Brent De Blacre, Jens Vankeirsbilek, and Jeroen Boydens. Utilizing parity checking to optimize soft error detection through low-level reexecution. IEEE Transactions on Reliabilily, 2023.
Adel Djoudi and Sébastien Bardin. Binsec: Binary code analysis with low-level regions. In International Conference Tools and Algorithms for the Construction and Analysis of Systems, pp. 212 217. Springer, 2015.
Ahmed Elnaggar, Wei Ding, Llion Jones, Tom Gibbs, Tamas Feher, Christoph Angerer, Silvia Severini, Florian Matthes, and Burkhard Rost. Codetrans: Towards cracking the language of silicon's 's code through self-supervised deep learning and high performance computing. arXiv preprint arXir:2104.0244: 2021.
Zhangyin Feng, Daya Guo, Duyu Tang, Nan Duan, Xiaocheng Feng, Ming Gong, Linjun Shou, Bing Qin, Ting Liu, Daxin Jiang, et al. Codebert: A pre-trained model for programming and natural languages. In Findings of the Association for Computational Linguistics: EMNLP 2020, pp. 1536-1547, 2020.
Jonathon T Giffin, Somesh Jha, and Barton P Miller. Efficient. context-sensitive intrusion detection. In NDSS, 2004.
Jianping Gou, Baosheng Yu, Stephen J Maybank, and Dacheng Tao. Knowledge distillation: A survey. International Journal of Computer Vision, 129(6):1789-1881) 2021.
Daya Guo, Shuo Ren, Shuai Lu, Zhangyin Feng, Duyu Tang, LIU Shujie, Long Zhou, Nan Duan, Alexey Svyatkovskiy, Shengyu Fu, et al. Graphcodebert: Pre-training code representations with data flow. In International Conference on Learning Representations, 2020.
Daya Guo, Shuai Lu, Nan Duan, Yanlin Wang, Ming Zhou, and Jian Yin. Unixcoder: Unified cross-modal pre-training for code representation. In Proceedings of the 60th Annual Meeting of the Association for Computational Linguistics ( (Volume 1: Long Papers), pp. 7212 22252225555 2022a.
25

---

Published in Transactions on Machine Learning Research (09/2025)
Yixin Guo, Pengcheng Li, Yingwei Luo, Xiaolin Wang, and Zhenlin Wang. Exploring gan based program embedding technologies for binary related tasks. In 2022 IEEE/ACM 30th International Conference on Program Comprehension (ICPC), pp. 366 377. LEEE, 2022b.
Irfan UI Haq and Juan Caballero. A survey of binary code similarity, ACM Computing Surveys (CSUR), 54 (3):1-38, 2021.
Laune C Harris and Barton P Miller. Practical analysis of stripped binary code. ACM SIGARCH Computer Architecture News, 33(5):63-668 68, 2005.
Kaiming He, Haoqi Fan, Yuxin Wu, Saining Xie, and Ross Girshick. Momentum contrast for unsupervised visual representation learning. In Proceedings of the IEEE/CVP conference on compuler vision and paltern recognition, pp. 9729 9738, 2020.
Paras Jain and Ajay Jain. Contrastive code representation learning. In Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing, 2021.
Yuan Jiang, Xiaohong Su, Christoph Treude, and Tiantian Wang. Hierarchical semantic-aware neural code representation. Journal of Systems and Software, 191:111355, 2022.
Jeremy Lacomis, Pengcheng Yin, Edward Schwartz, Miltiadis Allamanis, Claire Le Goucs, Graham Neubig, and Bogdan Vasilescu. Dire: A neural approach to decompiled identifier naming. In 2019 34th IEEE/ACM International Conference on Automated Software Engineering (ASE), pp. 628-639. IEEE, 2019.
Zhen Li, Deqing Zou, Shouhuai Xu, Hai Jin, Yawei Zhu, and Zhaoxuan Chen. Sysevr: A framework for using deep learning to detect software vulnerabilities. IEEE Transactions on Dependable and Secure Computing, 2021.
Chin- Yew Lin. Rouge: A package for automatic evaluation of summarics. In Text summarization branches out, pp. 74-81, 2004.
Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. Roberta: A robustly optimized bert pretraining approach. arXiv preprint Xiv: 11692, 2019.
Shuai Lu, Daya Guo, Shuo Ren, Junjie Huang, Alexey Svyatkovskiy, Ambrosio Blanco, Colin Clement, Dawn Drain, Daxin Jiang, Duyu Tang, et al. Codexglue: A machine learning benchmark datasel for code understanding and generation. In Thirty-fitth Conference Neural Information Processing Systems Datascts and Benchmarks Track (Round 1), 2021.
Andrea Marcelli, Mariano Graziano, Xabier Ugarte- Podrero, Yanick Fratantonio, Mohamad Mansouri, and Davide Balzarotti. How machine learning is solving the binary function similarity problem. In 31st USENIX Securily Symposium (USENIX Security 22), pp. 2099 201-2116, 2022.
Lili Mou, Ge Li, Lu Zhang, Tao Wang, and Zhi Jin. Convolutional neural networks over tree structures for programming language processing. In Proceedings of the Thärtieth AAAI Conference on Artificial Intelligence, pp. 1287-1293, 2016.
Andrew Mutton, Mark Dras, Stephen Wan, and Robert Dale. Glou: Automatic evaluation of sentence-level fluency. In Proceedings of the 45th Annual Meeting of the Association of Computational Linguistics, pp. 344-30 301, 2007.
Kishore Papineni, Salim Roukos, Todd Ward, and Wei-Jing Zhu. Bleu: method for automatic evaluation of machine translation. In Proceedings of the 40th annual meeting of the Association for Computational Linguistics, pp. 311-318, 2002.
Long Phan, Hicu Tran, Daniel Le, Hicu Nguyen, James Annibal, Alec Peltekian, and Yanfang Ye. Cotext: Multi-task learning with code-text transformer. In Proceedings of the 1st Workshop on Natural Language Processing for Programming (NIPP4Prog 2021). j. Association for Computational Linguistics, 2021.
26

---

Published in Transactions on Machine Learning Research (09/2025)
Jim Pierce and Trevor Mudge. Idtrace/spl minus/a a tracing tool for i486 simulation. In Proceedings of Inter- national Workshop on Modeling, Analysis and Simulalion of Compuler and Telecommunication Systems. pp. 419 420. LEEE, 1994.
Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, et al. Learning transferable visual models from natural language supervision. In International Conference on Machine Learning, pp. 1748. PMLR, 2021.
Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J Liu. Exploring the limits of transfer learning with a unified text-to-text transformer. Journal of machine learning research, 21(140):1-66 67, 2020.
M. Moein Shariatnia. Simple CLIP, 2021.
Ensheng Shi, Yanlin Wang, Lun Du, Junjic Chen, Shi Han, Hongyu Zhang, Dongmei Zhang, and Hongbin Sun. On the evaluation of neural code summarization. In Proceedings of the 44th International Conference on Software Engineering, pp. 1597-1608, 2022.
Zhan Shi, Kevin Swersky, Daniel Tarlow, Parthasarathy Ranganathan, and Milad Hashemi. Learning exe- cution through neural code fusion. In International Conference on Learning Representations, 2019.
Christos Thrampoulidis, Ganesh Ramachandra Kini, Vala Vakilian, and Tina Behnia. Imbalance trouble: Revisiting neural-collapse geometry. Advances in Neural Information Processing Systems, 35:27225-2723
2022.
Yonglong Tian, Chen Sun, Ben Poole, Dilip Krishnan, Cordelia Schmid, and Phillip Isola. What makes for good views for contrastive learning? Advances in Neural Information Processing Systems, 33:6827-6839, 2020.
Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. Advances in neural information processing systems, 30, 2017.
Yue Wang, Weishi Wang, Shafiq Joty, and Steven CH Hoi. Codet5: Identificr-aware unified pre-trained encoder-decoder models for code understanding and generation. In Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing, pp. 8696 8708, 2021.
Zheng Wang, Ken Pierce, and Scott McFarling. Bmat-a binary matching tool for stale profile propagation. The Journal of Instruction-Leve Parallelism, 2:1 2:1-20, 2000.
Tote Xiao, Xiaolong Wang, Alexci A Efros, and Trevor Darrell. What should not be contrastive contrastive learning. In International Conference on Learning Representations, 2020.
Fangke Ye, Shengtian Zhou, Anand Venkat, Ryan Marucs, Nesime Tatbul, Jesmin Jahan Tithi, Paul Pe- tersen, Timothy Mattson, Tim Kraska, Pradeep Dubey, al. Misim: An end-to-end neural code similarity system. arXiv preprint 2XXx:2006.05266 2020.
Chen Zeng, Yue Yu, Shanshan Li, Xin Xia, Zhiming Wang, Mingyang Geng, Linxiao Bai, Wei Dong, and Xiangke Liao. degraphcs: Embedding variable-based flow graph for neural code search. ACM Transactions on Software Engineering and Methodology, 2021.
Yifan Zhang, Junwen Yang, Haoyu Dong, Qingchen Wang, Huajie Shao, Kevin Leach, and Yu Huang. Astro: An ast-assisted approach for generalizable neural clone detection. arXie preprint arXiv:2208. 08067, 2022.
Jing Zhao, Xijiong Xie, Xin Xu, and Shiliang Sun. Multi-view learning overview: Recent progress and new challenges. Information Fusion, 38:43 54, 2017.
Fei Zuo, Xiaopeng Li, Patrick Young, Lannan Luo, Qiang Zeng, and Zhexin Zhang, Neural machine transla- tion inspired binary code similarity comparison beyond function pairs. In Proceedings 2019 Network and Distributed System Security Symposium. Internet Society, 2019.
27


Reviews:
[{"review_id": "TU2JIR0U4F", "reviewer": "Reviewer_pp3s", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "Strengths\n1. Novelty: The paper introduces a new contrastive learning paradigm that combines source code, binary code, and comments—an underexplored setup in binary analysis.\n\n2. Generalization: ContraBin is evaluated on four downstream tasks (classification, name recovery, summarization, reverse engineering), covering both analysis and comprehension.\n\nWeaknesses:\n1. Unfair and incomplete baseline comparisons. The baseline should be in the same training strategy.\n\n2. The motivation for simplex interpolation is loosely tied to “human gradual learning,” which lacks theoretical or empirical backing.\n\n3. The paper does not mention releasing code or pretrained models, which limits reproducibility and community adoption.", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "Yes", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "The paper proposes ContraBin, a contrastive learning framework for binary code representation that leverages triplets of source code, comments, and compiled binaries. It introduces a simplex interpolation module to generate intermediate views between modalities and a secondary contrastive learning objective to align these interpolated embeddings with binary representations. The authors also analyze the role of comment quality, finding that LLM-generated comments improve performance, while human-written ones often degrade it. ContraBin is evaluated on four binary analysis tasks, showing consistent performance gains over existing pretrained models.", "claims_and_evidence_yn": "Yes", "claims_explanation": "", "audience_yn": "Yes", "audience_explanation": "", "requested_changes": "See Weaknesses", "broader_impact_concerns": "N/A", "additional_comments": "", "extra_scores": {}, "extra_text": {}}, {"review_id": "wUlh6EVli6", "reviewer": "Reviewer_8Nws", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "### Strengths\n\n* Introduces a novel, well-motivated approach that combines contrastive learning with simplex interpolation to bridge the semantic gap between source code, comments, and binary code.\n* Methodology is theoretically grounded, inspired by human learning and multi-view representation learning.\n* Evaluation covers four diverse downstream tasks (binary classification, summarization, function name recovery, reverse engineering) across multiple datasets (POJ-104, DIRE, AnghaBench).\n* Provides valuable insights into the role of synthetic vs. human-written comments, showing that synthetic comments are surprisingly more effective for representation learning.\n* The gradual learning framework via primary and secondary contrastive learning is well-designed and shows clear empirical benefits.\n* Demonstrates extensibility by adapting the method to architectures like T5/CodeT5.\n* Ablation studies are effective in validating the contribution of each model component.\n* Case studies and embedding visualizations qualitatively support that learned embeddings capture meaningful semantic relationships in binary code.\n\n### Weaknesses\n\n* The comparison baselines are general-purpose NLP or code NLP models (RoBERTa, CodeBERT, GraphCodeBERT), rather than specialized binary analysis methods.\n* The paper does not compare ContraBin against relevant neural binary analysis methods like Bin2Vec, GNN-BPE, or InnerEye, even though these are mentioned in the related work.\n* The number of experimental trials is unclear; phrasing such as \"the random seed\" suggests only single runs were performed.\n* No error bars, confidence intervals, or statistical significance tests are reported, leaving uncertainty about whether observed gains are statistically meaningful.\n* Critical hyperparameter details are missing, including:\n\n  * The temperature parameter (τ) for contrastive loss\n  * Architecture details of the interpolation networks\n  * Optimizer configurations beyond basic learning rates\n  * Learning rate schedules and warmup settings\n* These omissions hurt reproducibility, despite the paper's claims of providing implementation details.", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "No", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "### Method: \nContraBin introduces a novel intermediate contrastive learning framework that uses simplex interpolation between source code, binary code, and comments to model the gradual learning process, enabling richer, semantically aligned binary code embeddings.\n\nStage 1: Primary Contrastive Learning -> Stage 2: Secondary Contrastive Learning with Simplex Interpolation -> Stage 3: Task-Specific Fine-tuning\n\n### Experiments:\n\nContraBin uses pre-trained encoders (primarily RoBERTa-based with extensions to T5/CodeT5) and is evaluated on four datasets: POJ-104 (algorithmic classification), DIRE (function name recovery), and AnghaBench (code summarization and reverse engineering), achieving significant improvements over baseline NLP models including RoBERTa, CodeBERT, and GraphCodeBERT. The method demonstrates substantial performance gains ranging from 2-18% across different metrics, with the most notable improvements being +14.34% MAP on POJ-104 classification and +13.60% accuracy on DIRE function name recovery compared to the RoBERTa baseline.", "claims_and_evidence_yn": "No", "claims_explanation": "", "audience_yn": "Yes", "audience_explanation": "", "requested_changes": "1. Include comparisons with binary code-specific models such as Bin2Vec, GNN-BPE, or InnerEye, with appropriate implementation details and justification for any architectural or task-specific adaptations, or explicitly explain why such comparisons were not feasible or appropriate for their evaluation.\n\n2. Conduct multiple experimental runs using different random seeds and report statistical metrics such as standard deviation or confidence intervals, or clearly state the number of runs and justify the use of single-run evaluations if applicable.\n\n3. Report statistical significance to demonstrate that the observed improvements are not due to chance, or provide error bars in the performance graphs to visually reflect variance.\n\n4. Provide complete hyperparameter documentation, including:\n\n   * the temperature parameter (τ) for contrastive loss,\n   * architectural details of the interpolation networks used in secondary contrastive learning,\n   * optimizer settings beyond just the learning rate (e.g., type, momentum, weight decay),\n   * learning rate schedules and warmup strategies,\n     or included a reproducibility appendix or configuration file to ensure the work can be reliably reproduced.", "broader_impact_concerns": "N/A", "additional_comments": "", "extra_scores": {}, "extra_text": {}}, {"review_id": "GDlKuUETIY", "reviewer": "Reviewer_JxQS", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "### Strengths\nS1: The paper tackles the gap between source-level and binary-level code understanding and is, to the best of my knowledge, the first to align **three modalities simultaneously (source, binary, comments)** using contrastive learning plus simplex interpolation.  \n\nS2: The separation into primary contrastive learning, simplex-based secondary learning, and task-specific fine-tuning is easy to follow, and ablations demonstrate each part’s contribution (to some degree, see weaknesses).  \n\nS3: ContraBin is tested on four diverse downstream tasks and shows consistent improvements over strong code baselines across those tasks.  \n\nS4: Beyond standard ablations, the authors analyze *human vs. synthetic* comments; the sharp drop when using real comments usefully highlights noise in developer annotations.  \n\nS5: A smaller experiment porting the method to a T5/CodeT5 backbone still yields gains, suggesting the idea is architecture-agnostic.  \n\nS6: Code, data, preprocessing scripts, and hardware details are publicly released, enabling full replication.  \n\n---\n\n### Weaknesses / Points to Clarify\n\nW1: Figure 6 aims to illustrate the quality of the embedding by the proposed method. You say: \"In contrast, embeddings from ContraBin (PCL) display a more structured distribution, where binary codes related to similar functionalities begin to cluster into distinct regions\". It is not clear how Figure 6 indicates this, please clarify. I don't see how your embedding leads to more clear clusters.\n\nW2: The results of the ablation studies (Table 7) is a very important part of the paper in order to understand the importance of the different components. However, you only evaluate this on one of the tasks (binary functional algorithm classification of POJ104).\n \nW3: The \"comment\" modality seems to help performance (from Table 7, assuming synthetic comments from LLM). However, this assumes access to some LLM capable of producing high quality synthetic comments for the given code. Can we assume that this can be done for other code datasets? Also, I am curious if more detailed ablation studies regarding the synthetic comments may reveal this modality to be more important than reported (indicating strong reliance on a separate LLM). \n\nW4: How are the baseline methods trained/finetuned? Are they pretrained on different data compared to your models? How would it impact performance if they are pretrained on the same data?\n\nW5: ContraBin (PCL) is sometimes outperformed by baselines. Given this, how can we know if the Primary Contrastive Learning step is needed/useful at all?\n\nW6: Training required several high-end GPUs, but runtime of training is not reported as far as I can tell.\n\nW7: ContraBin (PCL) in Table 3-4 and Interpolations in Table 7 seems to be the same thing. Was slightly confused by this. May be good to use a consistent name.\n\nW8: You say: \"To better fit the capacity of pre-trained language models, we further truncate the length of binary code by only selecting the first 512 instructions\". Real-world functions can be significantly longer. The impact of this truncation on the model's ability to handle longer, more complex binary sequences is not discussed. Does performance degrade significantly with longer sequences?\n\nW9: The paper claims to be the \"first language representation model to incorporate source code, binary code, and comments into contrastive code representation learning\"  and the \"first study to derive intermediate contrastive learning for binary code analysis\". While the specific combination and the intermediate contrastive learning for binaries are likely novel, the authors should be precise. The first claim is broad; ensuring it holds against all prior multi-modal code representation work (even if not specifically binary-focused or using a different learning paradigm) is important. The second claim is more specific and likely easier to defend.\n\nW10: The concept of \"gradual learning\" (from simple to complex)  is used to motivate the two-stage training. While intuitive, the paper could benefit from a more direct analysis or evidence showing that this staged approach (primary CL then secondary CL with interpolation) is superior to, for example, introducing all components from the start, or if the model indeed learns qualitatively different things at each stage that build effectively. The multi-objective vs. multi-step comparison supports the staged approach over a single combined loss, which is good, but further insight into the \"gradual\" aspect would be welcome.", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "Yes", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "The paper presents ContraBin, a contrastive learning framework for pre-training embeddings of binary code by leveraging three modalities: source code, compiled binary code, and natural language comments. It introduces a two-stage training process—primary contrastive learning between modality pairs, followed by simplex interpolation and intermediate contrastive learning—to align semantically similar representations across these views. Notably, the authors show that machine-generated comments improve performance, while human-written ones often introduce noise.\n\nContraBin is evaluated on four binary code tasks: functionality classification, function name recovery, summarization, and reverse engineering. It consistently outperforms baselines like RoBERTa, CodeBERT, and GraphCodeBERT, demonstrating strong generalization and semantic alignment across modalities.\n\nAblation studies highlight the importance of each component, particularly simplex interpolation and LLM-generated comments. Attempts to use multi-objective loss instead of the staged approach lead to severe performance drops, underscoring the effectiveness of ContraBin’s design in capturing meaningful binary code representations.", "claims_and_evidence_yn": "Yes", "claims_explanation": "", "audience_yn": "Yes", "audience_explanation": "", "requested_changes": "See weaknesses above. The following are most critical: W1, W2, W3, W4, W5.", "broader_impact_concerns": "None.", "additional_comments": "", "extra_scores": {}, "extra_text": {}}]

Author rebuttal:

Decision: Accept (poster)