Enhancing LLM-Based Code Translation with Verified Multi-Semantic Representations

Unknown

Conceptio › Archive › arXiv CS

arXiv CSopen access

Enhancing LLM-Based Code Translation with Verified Multi-Semantic Representations

Unknown · 2026 · arxiv_cs

arXiv CS · Papers · License: Open Access · 2026

Open Source ↗Direct PDF ↓

softwarearchitecture softwareengineering testing

software engineering, software architecture, testing

arXiv:2606.11863v1 [cs.SE] 10 Jun 2026

E NHANCING LLM-BASED C ODE T RANSLATION WITH V ERIFIED M ULTI -S EMANTIC R EPRESENTATIONS

Yufu Wang School of Software Dalian University of Technology Dalian 116024, China [email protected]

He Jiang School of Software Dalian University of Technology Dalian 116024, China [email protected]

Peiyu Zou School of Computer Science and Artificial Intelligence Liaoning Normal University Dalian 116029, China [email protected]

Hao Lin School of Software Dalian University of Technology Dalian 116024, China [email protected] Ang Jia School of Software Dalian University of Technology Dalian 116024, China [email protected]

Zhilei Ren School of Software Dalian University of Technology Dalian 116024, China [email protected]

Xiaochen Li School of Software Dalian University of Technology Dalian 116024, China [email protected]

June 11, 2026

A BSTRACT Large language models (LLMs) have shown great promise for automated code translation. However, existing approaches mainly rely on token-level statistical patterns for mapping, rather than generating target code based on a sufficient understanding of program semantics. As a result, translation outputs often contain intervenable logical and semantic errors. Such errors can potentially be mitigated by incorporating high-quality semantic guidance, such as functional descriptions and test cases. However, in real-world scenarios, these external semantic resources are often unavailable, making it necessary to construct semantic information directly from the source code to guide translation. This gives rise to two key challenges: first, how to construct semantic information that is sufficiently rich and diverse to characterize program behavior from multiple complementary perspectives; second, how to ensure that such semantics are accurate and reliable enough to effectively guide LLMs in code translation even in the absence of external resources. To address these challenges, we propose Multisage, a multisemantic augmentation and self-calibration framework for LLM-based code translation. Multisage comprises three core modules. First, a semantic representation parsing module extracts structured base semantic representations from source code, including data-flow graphs, type-constraint analysis, and external API information. These representations capture intrinsic program semantics and provide the foundation for subsequent augmentation. Second, a multi-semantic augmentation module builds upon these base semantic representations to construct augmented semantics, such as function-level test cases, code summaries, and API-oriented descriptions and test cases, thereby expanding semantic coverage across different aspects of program behavior. Finally, a semantic consistency calibration module introduces semantics-preserving code mutations and cross-semantic consistency verification to automatically filter, calibrate, and refine the augmented semantics, ensuring their accuracy and reliability. Extensive experiments on the HumanEval-X code translation benchmark show that Multisage improves translation success rates by up to 2.22× across diverse backbone models. It consistently outperforms vanilla prompting, instruction-tuned LLMs, and Chain-of-Thought (CoT)

A PREPRINT - J UNE 11, 2026

reasoning, with the largest relative gains observed on smaller models with limited capacity. These results demonstrate that explicit semantic augmentation effectively strengthens the reliability of LLM-based code translation. Keywords Code translation · Large language model · Semantic augmentation · Semantic calibration · Software reliability Code translation refers to the automated process of converting source code from one programming language to another while preserving functional equivalence [1], [2]. It plays a critical role in cross-language migration and software modernization, enabling developers to maintain and evolve large-scale systems more efficiently. As software ecosystems continue to expand and multiple programming paradigms coexist, code translation has become an essential component of software reengineering. In practice, many enterprise systems still rely on legacy programming languages whose limitations hinder maintainability, scalability, and security, leading to substantial migration and integration costs. In this context, machine learning–based automatic code translation has emerged as a promising research direction [3], [4], [5]. These approaches learn behavioral and functional constraints from source code and generate functionally equivalent constructs in the target language, enabling high-quality translation without extensive manual intervention [6], [7], [8]. Compared with rule-based systems or handcrafted conversion templates, learning-driven code translation substantially improves efficiency, reduces semantic deviation, and provides essential support for downstream tasks such as crosslanguage program understanding [9], automated bug repair [10], and knowledge transfer [11]. With the advent of the Transformer architecture [12], LLMs pre-trained on extensive code corpora have further advanced the field of automatic code translation. For example, CodeBERT [13] achieves strong performance across multiple downstream code-related tasks through pre-training on large-scale code data. Meanwhile, TransCoder [4] combines unsupervised learning with back-translation and is trained on massive monolingual code datasets to acquire code translation capabilities. However, despite these advances, such approaches often struggle to capture key semantic constraints when handling complex cross-language differences, leading to logical or functional inconsistencies [14], [7]. Recent studies have attempted to improve translation reliability by introducing additional semantic information to guide generation [15], [16], [17], [18]. For example, Rozière et al. [15] incorporate language-agnostic semantic abstractions to enhance model understanding of source programs, while Yang et al. [17] employ automatically generated test cases to validate model outputs. Although these approaches provide stronger constraints for translation models, they typically address only localized failure modes and remain insufficient for handling complex semantic dependencies in real-world programs. When program semantics involve intricate dependencies and significant cross-language differences, models still struggle to preserve logical consistency and functional equivalence. A closer analysis of translation outputs reveals that many failures are in fact intervenable, including logical inconsistencies, dependency misalignment, and data-parsing errors [14], [7]. These errors exhibit structured patterns rather than purely stochastic behavior, suggesting that they often stem from a common root cause: the lack of explicit and reliable semantic information during translation, as well as the absence of mechanisms to verify and calibrate such information. Consequently, models rely on token-level probabilistic associations for alignment, which can produce unstable outputs in complex scenarios [14], [19]. To mitigate this issue, prior work introduces external semantic resources such as test cases, documentation, or formal specifications to strengthen translation constraints [17], [15]. However, such resources are often unavailable in real-world software systems. Therefore, improving the reliability of LLM-based code translation requires systematically constructing and enforcing key semantic constraints directly from source code. This requirement gives rise to two key challenges: • Constructing multi-semantic information: In program analysis and code understanding, semantics refers to information that characterizes program behavior, logical relations, and functional constraints [20]. Such information directly determines the functional correctness and consistency of translation results [21, 22]. Prior studies [23, 24] show that different semantic perspectives capture complementary aspects of program behavior, including control relations along execution paths, value propagation, and constraints governing function and API usage. However, these perspectives differ in representation and focus, and any single semantic form typically captures only a limited facet of program behavior. Consequently, relying on a single semantic representation makes it difficult to cover the diverse semantic constraints required across execution contexts. A key challenge is therefore how to systematically construct multiple complementary semantic forms directly from source code to improve overall semantic coverage. • Ensuring the accuracy and reliability of semantic information: Semantic information is often constructed through static inference, approximate assumptions, or limited contextual evidence, making it susceptible to noise, incompleteness, and bias [21]. Different semantic perspectives may therefore introduce conflicting or inconsistent constraints. When such imperfect semantics are directly used to guide translation models, they may fail to correct errors and even mislead the model to produce outputs that appear plausible but deviate 2

A PREPRINT - J UNE 11, 2026

from the intended behavior [25, 26]. A key challenge is thus how to systematically verify, filter, and calibrate semantic information so that it provides reliable guidance during translation. To address these challenges, we propose Multisage, a multi-semantic augmentation and self-calibration framework for LLM-based code translation. Multisage consists of three core modules. First, a semantic representation parsing module extracts structured semantic units from source code through static analysis. Second, a multi-semantic augmentation module generates complementary semantic views, including code summaries, API usage information, and function-level test cases, to enhance semantic coverage. Third, a semantic consistency calibration module performs semanticspreserving mutations and cross-view consistency verification to filter unreliable semantic signals. Together, these modules construct, verify, and calibrate semantic information, enabling LLMs to utilize not only richer semantics but also explicitly modeled and reliable semantic guidance during translation. We conduct a systematic study on the HumanEval-X benchmark using LLMs with diverse architectures and parameter scales to evaluate the effectiveness and cross-model generalization of Multisage. Under vanilla prompting, Multisage improves translation success rates by up to 2.22×, with consistent gains across all evaluated models. We further compare Multisage with representative specialized code translation models, such as TransCoder, under identical evaluation settings. Multisage achieves substantially higher CodeBLEU scores while maintaining competitive execution success rates, indicating that explicit multi-semantic augmentation provides more comprehensive implementation-level semantic constraints than approaches relying primarily on structural modeling or model-specific design. Compared with alternative semantic enhancement strategies such as CoT reasoning and single-stage semantic prompting, Multisage consistently improves translation success rates by up to 1.42× on small-scale models, 1.28× on mid-scale models, and 1.17× on large-scale models. Overall, these results demonstrate that Multisage provides strong and stable performance gains across diverse model configurations, effectively reducing intervenable semantic errors and enhancing the reliability of LLM-based code translation. The main contributions of this work are summarized as follows: • We identify and analyze a key limitation of existing LLM-based code translation: most failures are intervenable semantic errors caused by the lack of explicitly modeled and reliable semantic constraints, rather than insufficient model capacity or randomness. Detailed error categorization and quantitative statistics are presented in Section 1.3. • We propose Multisage, a multi-semantic augmentation and self-calibration framework for LLM-based code translation. Multisage integrates three cooperative components: semantic representation parsing, multisemantic augmentation, and semantic equivalence tuning, to systematically construct diverse and complementary semantic forms solely from source code. The framework constructs and calibrates diverse semantic representations from source code to provide reliable and controllable semantic guidance for translation. • We conduct comprehensive evaluations on HumanEval-X with multiple LLMs of varying scales, showing that Multisage consistently improves translation success rates across models, achieving gains of up to 2.22×, and outperforming representative semantic enhancement strategies.

Background and Motivation

1.1

LLM-Based Code Translation

Automatic code translation aims to convert programs from one programming language into semantically equivalent implementations in another [3], [16]. With the rapid development of LLMs, recent LLM-based approaches have significantly advanced the state of the art in code translation [13], [4]. By leveraging large-scale pretraining on code corpora and strong generative capabilities, LLMs can produce target-language code that is syntactically fluent and stylistically consistent, often resembling human-written implementations [27], [8]. Despite their impressive performance, LLM-based code translation systems face fundamental challenges inherent in the generative nature of LLMs. Code translation is a strictly semantics-preserving task, where even subtle deviations in control flow, data dependencies, or API usage may result in incorrect program behavior. However, LLMs primarily model token-level probability distributions and lack built-in mechanisms for explicit semantic verification. As a result, they may generate translations that appear plausible on the surface but violate essential semantic constraints [26]. Most existing LLM-based code translation methods are built upon large-scale code corpora, from which they learn statistical correspondences between source and target languages. While this data-driven paradigm works well for common translation patterns, it often struggles when accurate translation requires a deeper understanding of program intent, execution behavior, or the semantics of external libraries. As a result, LLMs may generate translations that are 3

A PREPRINT - J UNE 11, 2026

(a)

(b)

(c)

Figure 1: Categories of LLM-Based Code Translation Failures. (a) Dependency and Logical Errors. (b) Data Parsing Errors. (c) Model-Specific Errors.

syntactically valid but semantically incorrect, especially for programs involving complex logic, conditional structures, or non-trivial API interactions [14]. Importantly, such errors arise not only from model capacity limitations but also from the absence of explicit mechanisms for exposing and enforcing semantic constraints during generation [7], [17]. 1.2

Semantic Information

Program semantics describes the meaning and behavior of a program, including how inputs are processed, how internal states evolve, and what outputs are produced [20], [21]. Prior studies show that program semantics can be represented through multiple complementary forms that capture different aspects of program behavior [21]. Among these forms, natural-language code summaries provide high-level descriptions of program functionality and developer intent, which have been shown to improve downstream tasks such as code search and understanding [21], [23]. In addition, test cases serve as practical carriers of semantic constraints by explicitly specifying input–output behaviors and expected program functionality [24], [22]. For LLM-based code generation and translation, such semantic information helps bridge the gap between surface-level code patterns and deeper program understanding. By providing explicit semantic signals such as summaries, API properties, and test cases, models can better align generated code with the intended functionality. This capability is particularly important for code translation, where semantic preservation is required. 1.3

Motivation

To better understand the limitations of existing LLM-based code translation approaches, we conduct a systematic empirical analysis of translation outputs across multiple models. The results indicate that a substantial proportion of failures can be attributed to intervenable semantic errors, which typically arise from missing or misinterpreted semantic constraints. Meanwhile, a smaller portion of failures is associated with model capacity limitations or stochastic decoding behaviors. These findings suggest that improving the reliability of code translation hinges on systematically introducing explicit and verifiable semantic constraints. To further analyze the structure of these failures, we categorize common failure modes into three types, as illustrated in Fig. 1 [7, 14]. The first category, dependency and logical errors, includes issues such as unresolved dependencies, incorrect API usage, or flawed control-flow reasoning. The second category, data parsing errors, involves structural or type-level inconsistencies, such as mismatched return formats or invalid type handling. These two categories correspond to intervenable translation errors, as they primarily arise from missing or misinterpreted semantic constraints and can, in principle, be mitigated through appropriate semantic guidance or auxiliary analysis [7], [14]. In contrast, the third category, model-specific errors, refers to meaningless or ill-formed outputs produced by the model itself, which cannot be effectively corrected through semantic constraints and are largely determined by the model architecture and decoding process. To quantify the prevalence of these error types, we analyze models with different parameter scales and architectures. As shown in Fig. 2, models are grouped into three categories: high-performance large models (HP-LLMs, >100B parameters), mid-scale models (MS-LLMs, 10B–100B), and lightweight models (ℓLMs, <10B). Across HP-LLMs and 4

A PREPRINT - J UNE 11, 2026

Figure 2: Proportion of Code Translation Failure Types Across LLM Scales. Percentages are rounded to the nearest integer and may not sum to exactly 100%.

most large models, the majority of translation failures fall into the intervenable category, whereas model-specific errors account for only a small fraction. Even for lightweight models, model-specific errors typically represent only 10%–23% of failures, indicating that most translation errors are potentially correctable. Fig. 3 provides a concrete example. When translating a C++ function that validates identifiers using std::regex_match, a vanilla StarCoder2-15B model generates syntactically valid Java code but performs partial pattern matching instead of enforcing a full match. By providing explicit semantic guidance such as a code summary, API semantics specifying full-match requirements, and minimal test cases, the model produces a semantically correct translation. This example illustrates that many failures arise not from code generation ability but from the absence of explicit semantic constraints. Taken together, these observations point to a key insight: improving LLM-based code translation therefore does not primarily require larger models, but rather mechanisms that expose and leverage semantic information during translation. Since many failures are intervenable, incorporating explicit semantic signals offers a practical path toward more reliable and semantics-preserving code translation. While these findings highlight the importance of semantic grounding, simply exposing semantic information is insufficient. Program semantics are inherently multi-faceted, encompassing functional intent, API constraints, type relations, and control dependencies. A single representation therefore, cannot fully capture the complex behavior of real-world programs. A key challenge is how to systematically derive complementary semantic representations from source code to provide comprehensive guidance for translation. Another challenge concerns the reliability of constructed semantics. Because semantic information is often derived through approximate inference, it may contain noise or inconsistencies. Without proper filtering and calibration, such imperfect semantics may mislead the model. Therefore, effective semantic mediation requires mechanisms to both construct diverse semantic representations and verify their reliability. In the next section, we present such a framework, which operationalizes multi-semantic construction and self-calibration to provide reliable semantic guidance for code translation. 5

A PREPRINT - J UNE 11, 2026

(a)

(b)

Figure 3: Impact of Explicit Semantic Information on Code Translation. (a) Translation without Explicit Semantic Guidance. (b) Translation with Explicit Semantic Guidance.

Figure 4: Workflow of Multisage.

Framework

2.1

Overview

Multisage is a multi-semantic augmentation and self-calibration framework for LLM-based code translation. As illustrated in Fig. 4, it consists of three modules: semantic representation parsing, multi-semantic augmentation, and semantic consistency calibration. Given a source-language function, the framework first reconstructs structured semantic 6

A PREPRINT - J UNE 11, 2026

representations from the code, then generates diverse semantic views, and finally calibrates these semantics before providing them together with the original code to the LLM as semantically grounded guidance for translation. The semantic representation parsing module performs static analysis on the input program to construct a languageagnostic semantic representation that captures control flow, type constraints, and API dependencies. This structured base semantic representation serves as the foundation for subsequent semantic augmentation and calibration. The multi-semantic augmentation module then derives complementary semantic views from the parsed base semantic representations, including code summaries, API semantic descriptions, and function-level test cases. These heterogeneous views capture program behavior, constraints, and usage intent from different perspectives, improving the model’s ability to preserve semantic dependencies during translation. Finally, the semantic consistency calibration module improves the reliability of the constructed semantics through semantics-preserving code mutations and cross-view consistency checking. It identifies and filters unreliable semantic signals and organizes the calibrated semantics into a structured prompt together with the original code. This process provides stable semantic guidance for the LLM and improves the functional correctness and robustness of translation. 2.2

M1: Code Representation Parsing Module

The code representation parsing module aims to structurally parse and reconstruct semantic representations from source code, focusing on three explicit and machine-interpretable semantic aspects: control flow, type constraints, and external interfaces. The module performs static analysis to generate structural templates and dependency descriptions, which provide logical foundations and structural constraints for subsequent semantic augmentation and cross-language code generation. The resulting set of structured semantics is collectively referred to as the basic semantic representation (Rbase ), which serves as the input to the subsequent multi-semantic augmentation module. Control Flow Extraction. Control flow forms the backbone of a function’s logic, capturing the execution order and branching behavior among statements. To extract this structure, we perform static analysis over the source program using an abstract syntax tree (AST) parser1 and a control flow graph (CFG) generator2 , where the AST provides structural boundaries for statements and control constructs, and the CFG captures the corresponding execution paths. The CFG captures the control-flow structure of program execution, where nodes correspond to statement blocks and edges denote execution paths, including conditional branches, loops, and exception handling. The extracted CFG is then linearized into a structured execution template using block-ordering techniques, which is included as one component of the Rbase . The linearization follows a depth-first traversal over the CFG, where conditional and loop structures are explicitly encoded as structured control tokens. For example, consider the following C++ function: int maxValue ( int a , int b ) { if ( a > b ) return a ; else return b ; }

Its control flow can be represented as: Entry → Condition ( a > b ) → { True : return a | False : return b } → Exit

Type Constraint Parsing. Since our focus is on preserving functional semantics rather than implementation details, we extract only the function interface and its input–output types. Using the AST derived from the parser, we analyze function signatures to identify formal parameters and return types. These constraints are encoded into a structured type-constraint representation and injected into the LLM prompt to regulate variable declarations and return-value inference during code generation, thereby encouraging type-consistent generation and improving semantic alignment. External Interface Extraction. External interfaces define how a function interacts with its surrounding environment, including library dependencies, API invocations, and input–output behaviors that are not fully captured by internal control or type structures. To model these aspects, we analyze function bodies using the AST to identify external symbols, such as library function calls, object method invocations, and imported modules. These elements are further normalized into a structured interface representation, where each external interaction is abstracted into a canonical form consisting of the invoked entity, its arguments, and its functional role (e.g., I/O 1 2

https://tree-sitter.github.io/tree-sitter https://github.com/joernio/joern

A PREPRINT - J UNE 11, 2026

operation, container manipulation, or numerical computation). This abstraction reduces language-specific variability while preserving essential semantic intent. The extracted interface information is incorporated into Rbase as a complementary semantic component, enabling the model to better align external behaviors across programming languages. By explicitly exposing these dependencies, the model is guided to generate target code that preserves critical interactions with external systems and libraries. 2.3

M2: Multi-Semantic Augmentation Module

The multi-semantic augmentation module aims to enrich the base semantic representation Rbase by introducing diverse and complementary semantic signals that are not fully captured by structural analysis alone. Given Rbase as input, this module constructs and refines multiple forms of explicit semantic information, including functional summaries, test cases, and API-level descriptions, to provide comprehensive semantic guidance for code translation. The overall workflow of this module is illustrated in Fig. 5. Specifically, the module operates in three stages: (1) multisemantic data construction, where diverse semantic views are generated and validated; (2) multi-semantic augmentation model fine-tuning, where a unified model is trained to capture cross-semantic relationships; and (3) multi-semantic augmentation model inference, where multiple semantic signals are jointly produced and iteratively refined. The resulting augmented semantics serve as a richer and more reliable semantic representation for subsequent semantic consistency calibration. Multi-Semantic Data Construction. Due to the lack of high-quality datasets that comprehensively cover multiple semantic dimensions of source code, existing large language models often struggle to learn complex code semantics sufficiently from a single supervision signal. To address this limitation, we propose an LLM-based automatic multisemantic data construction approach, whose overall workflow is illustrated as Step 1 in Fig. 5. We first adopt the composite code datasets XLCoST [26] and XCodeEval [28] as the raw seed code–text datasets, both of which provide natural-language functional requirements paired with corresponding code snippets and thus serve as structured input–output templates for multi-task modeling. We then treat the source code P as the core modeling unit and, based on the base semantic representation Rbase produced by the code representation parsing module, leverage an LLM-based semantic generation agent to construct a Multi-Semantic Dataset that covers diverse semantic perspectives, including function-level code summaries, function-level test cases, and API-level semantic descriptions with associated test cases. To ensure the reliability and task consistency of the generated semantic information, we further introduce an execution validator that performs executability checking over the generated function-level and API-level test cases. Samples that pass validation are directly added to the Multi-Semantic Dataset, whereas those that fail trigger the generation of a Corrective Signal, which drives multi-round semantic refinement and correction. Guided by this feedback signal, the LLM regenerates or locally adjusts the corresponding semantic outputs, enabling test-case–like samples to gradually converge toward semantically consistent and logically complete states across different semantic perspectives. Representative prompting templates for semantic generation and refinement are provided in Appendix A. Multi-Semantic Augmentation Model Fine-Tuning. To achieve cross-semantic sharing and dynamic optimization balancing, Multisage introduces a multi-task joint fine-tuning mechanism inspired by FAMO [29] and MFTCoder [30] during the training of the multi-semantic augmentation model. This mechanism adaptively adjusts the loss weights of different semantic tasks throughout training, thereby dynamically coordinating their convergence speeds and improving the overall stability and robustness of optimization. Unlike traditional single-task fine-tuning or naive multi-task training, Multisage treats each semantic task as an independent optimization objective, which is jointly optimized within a shared parameter space. Assume there are N semantic generation tasks, and each task Ti is associated with a training dataset Di = (j) (j) (j) (j) i {(xi , yi )}M denotes the j-th input sample drawn from the Multi-Semantic Dataset, yi reprej=1 , where xi sents the corresponding task-specific target, and Mi is the total number of samples for task Ti . The overall optimization objective of Multisage is defined as a weighted multi-task loss:

L(θ) =

N X

wi ·Li (θ)

(1)

i=1

where Li (θ) is the loss function of the i-th task with model parameters denoted as θ, and wi denotes the i-th normalized adaptive task weight, which dynamically balances the importance and convergence rate of different tasks during training. The adaptive weights wi are updated according to the relative improvement of each task during training, enabling automatic coordination of task convergence. 8

A PREPRINT - J UNE 11, 2026

Figure 5: Workflow of Multi-Semantic Augmentation Module.

Detailed formulations of the weighting strategy and optimization procedure are provided in Appendix B. Multi-Semantic Augmentation Model Inference. During inference, given a source code P , we first obtain its base semantic representation Rbase from the code representation parsing module and feed Rbase into the multi-semantic augmentation model. The model then generates multiple forms of explicit semantic outputs in parallel, including function-level code summaries, API-level semantic descriptions, API-level test cases, and function-level test cases. To ensure the practical usability of the generated semantics, the API-level and function-level test cases are automatically submitted to an execution validator, which only checks whether the test cases can be successfully compiled and executed. If a test case passes validation, the corresponding semantic output is retained; otherwise, the system triggers regeneration of the test cases for the associated function or API. During this multi-round refinement process, only test cases related to failed functions or APIs are regenerated, while previously validated outputs remain unchanged. The generate–validate loop is executed for at most three refinement rounds. If validation still fails after three rounds, further refinement is skipped, and the sample is marked as a low-confidence instance to be handled uniformly by the subsequent semantic consistency calibration module. 9

A PREPRINT - J UNE 11, 2026

2.4

M3: Semantic Consistency Calibration Module

To further improve the accuracy and reliability of the constructed semantic guidance, Multisage introduces a semantic consistency calibration module. The core idea is that semantically equivalent programs should induce highly consistent semantic representations, even if their surface forms differ. Therefore, instead of directly trusting the initial augmented semantics S0 , we evaluate its stability by comparing it against semantics reconstructed from semantics-preserving program variants. Concretely, given the source code P , the equivalence mutator generates an equivalent mutant set {P ′ }. Each mutant P ′ is then processed by the modules M1 and M2, to obtain its mutant base semantics set R′base and the corresponding mutant augmented semantics set {S ′ }. The consistency evaluator computes a consistency score C between the S0 and {S ′ }. When C exceeds a predefined threshold τ , we regard S0 as sufficiently reliable and directly use it as the final semantic guidance. Otherwise, the semantic calibration unit is activated to selectively integrate the most consistent semantic components across S0 and {S ′ }, producing the calibrated final semantics Sf inal . This mechanism enables Multisage to automatically filter noisy or contradictory semantics and provide the LLM with stable, semantically grounded guidance for code translation. Equivalence Mutator. The equivalence mutator generates a small set of semantics-preserving program variants to assess the stability of augmented semantics. The underlying principle is that semantically equivalent programs, despite syntactic differences, should induce consistent semantic representations. Therefore, instability across equivalent variants indicates potential noise or overfitting in the constructed semantics. Given a source program P , the mutator produces a set of equivalent variants {P ′ } through static rule-based transformations applied to its AST and CFG representations. These transformations are designed to preserve program behavior for all valid inputs. We instantiate the mutator along three transformation dimensions: 1) Expression-level rewrites, which apply algebraic or logically equivalent transformations to side-effect-free expressions; 2) Control-flow–preserving rewrites, which restructure conditional and loop constructs while maintaining equivalent execution paths; 3) API-level substitutions, which replace library calls with verified equivalent alternatives under identical preconditions. All transformations are purely static and deterministic, operating on AST, CFG, and symbol-table representations without learned components. Variants that fail compilation or execution checks are discarded by the downstream validator, ensuring that only behaviorally consistent mutants are retained. The complete set of transformation rules is provided in Appendix C. In practice, we generate 3–5 equivalent variants for each input program. Consistency Evaluator. The consistency evaluator measures the stability of the initial augmented semantics S0 by comparing it against the mutant augmented semantics set {S ′ } reconstructed from the equivalent mutants. Our design is grounded in a well-established conclusion in [31] that equivalent mutants behave identically to the original program for all possible inputs, and thus preserve the same observable semantics despite syntactic differences. Prior work [32] on program semantics and code representation learning further argues that semantic representations should remain invariant under semantics-preserving program transformations, rather than being tied to surface-level syntax. Motivated by these findings, we assume that semantically equivalent programs should induce highly consistent semantic representations, and large deviations mainly indicate instability or noise in the constructed semantics. Directly requiring natural-language descriptions in S0 and {S ′ } to be exactly identical is, however, unrealistic, since semantically equivalent descriptions may differ in wording or structure. To address this, we normalize each semantic output into a set of semantic units U (S), where a unit corresponds to an API-usage constraint, a functional intent statement, or a behavioral assertion in a test case. We then compare semantic units based on token-level similarity rather than exact string matching. For each semantic unit u ∈ U (S0 ), we define the set of mutants in which u can be matched as: M(u) = {S ′ ∈ {S ′ } | ∃v ∈ U (S ′ ) s.t. sim(u, v) ≥ δ}

(2)

The similarity function sim(u, v) is implemented as token-level Jaccard similarity: sim(u, v) =

|T (u) ∩ T (v)| |T (u) ∪ T (v)|

(3)

with T (u) and T (v) denoting the sets of normalized tokens extracted from u and v, respectively. Token normalization includes lowercasing, stop-word removal, and preserving identifiers, API names, and key action verbs. This lightweight 10

A PREPRINT - J UNE 11, 2026

metric has been widely used in software-engineering text analysis, and allows us to measure semantic overlap without introducing additional neural models. We introduce a similarity threshold δ to determine whether two semantic units are considered matched, i.e., they are treated as aligned only when their informative tokens sufficiently overlap. The support of semantic unit u is defined as the fraction of mutants in which u can be matched: supp(u) =

|M(u)| |{S ′ }|

(4)

We then define the stable semantic unit set as U stable = {u ∈ U (S0 ) | supp(u) ≥ ρ}

(5)

where ρ is the majority-support threshold. We adopt a majority-support threshold of ρ = 0.5 when determining whether a semantic unit is stable. This design follows the classical majority-vote principle: if more than half of the equivalent mutants reproduce the same semantic unit (under similarity threshold δ), the unit is highly likely to reflect the true program semantics rather than noise introduced during augmentation. Finally, the consistency score C ∈ [0, 1] between the S0 and {S ′ } is computed as: C=

|U stable | |U (S0 )|

(6)

which quantifies the proportion of semantic units in S0 that are consistently supported by the equivalent mutants under similarity threshold δ. In all experiments, we set the consistency threshold τ to 0.6. This value reflects the following rationale: each semantic unit must be confirmed by the majority of equivalent mutants to be considered stable, while τ = 0.6 further requires that most units in S0 are stable, yet allows moderate variation in wording and coverage. Empirically, higher thresholds over-filter useful semantics, whereas lower thresholds tend to admit noisy or unstable semantics. If C ≥ τ , we regard S0 as stable and reliable, and it is directly used as the final semantic guidance. Otherwise, the semantic calibration unit is triggered to selectively aggregate the most consistent semantic units across S0 and {S ′ }, yielding the calibrated final semantics Sf inal . This design enables Multisage to explicitly quantify semantic reliability and suppress spurious artifacts introduced during augmentation, thereby providing the translation model with semantically grounded and cross-implementation–consistent guidance. Semantic Calibration Unit. When the consistency score C is below the reliability threshold τ , the initial augmented semantics S0 may contain unstable or noisy components. In this case, Multisage activates the Semantic Calibration Unit, which aggregates only the semantic units that obtain majority support across the initial and mutant semantics, and reconstructs a calibrated final semantic set Sf inal . We first construct the candidate semantic unit pool by collecting semantic units from both the initial semantics and the mutant semantics: U all = U (S0 ) ∪

[

U (S ′ )

(7)

S ′ ∈{S ′ }

For each unit u ∈ U all , its support is computed as equation(7). A semantic unit is considered reliable if it satisfies the majority-support condition supp(u) ≥ ρ. We then define the consensus semantic unit set as: U cons = u u ∈ U all and supp(u) ≥ ρ

(8)

Finally, the calibrated semantics are obtained by reconstructing the structured semantic representation from the consensus unit set: Sfinal = Aggregate(U cons )

(9)

where Aggregate(·) denotes the reconstruction of a structured semantic representation (including summaries, API-level semantics, and test-case constraints) from the consensus unit set. In practice, the aggregation preserves the task structure 11

A PREPRINT - J UNE 11, 2026

Table 1: Statistics of the C++ samples in the seed code-text datasets. Source Dataset

# C++ Samples

XCodeEval

95,425

XLCoST

11,198

Total

106,623

of S0 (e.g., summary, API-level semantics and test constraints), while replacing or supplementing unstable components using majority-supported units from U cons . This allows Multisage to deliver stable, cross-implementation–consistent, and noise-suppressed semantic guidance to the translation model, even when the initial semantics are unreliable. The semantic consistency calibration module involves three threshold-based parameters: the unit-level similarity threshold δ, the majority-support ratio ρ, and the global consistency threshold τ . These parameters control how strictly Multisage filters unstable or contradictory semantics. In this work, we set the default values to δ = 0.7, ρ = 0.5, and τ = 0.6. These choices reflect intuitive design considerations: δ = 0.7 enforces a relatively high but not prohibitive similarity requirement at the semantic-unit level, ρ = 0.5 requires at least majority agreement across variants, and τ = 0.6 ensures that global semantic instability triggers calibration only when sufficiently strong evidence accumulates. We stress that these values are not the result of fine-tuning for peak performance. As shown later in Section 4.5, Multisage remains stable across wide parameter ranges, indicating that our framework is robust to reasonable variations in these thresholds.

Experimental Setup

3.1

Datasets

Seed Code–Text Datasets. We leverage two publicly available code–text datasets, XCodeEval [28] and XLCoST [26], as the seed corpora for multi-semantic data construction. Both datasets provide executable source code paired with natural-language comments or summaries, enabling alignment between program logic and textual semantics. XCodeEval is a large-scale multilingual benchmark derived from the Codeforces platform3 , containing approximately 7,514 algorithmic problems with diverse executable contexts. XLCoST is collected from GeeksForGeeks4 and provides paired code and natural-language descriptions across multiple programming languages such as C++ and Java. Table 1 summarizes the statistics of the extracted C++ samples. Since our study focuses on C++→Java translation, we extract the corresponding C++ programs and apply standard preprocessing, including comment removal and dataset deduplication. Multi-Semantic Augmented Dataset. Leveraging the proposed Multi-Semantic Data Construction pipeline, we systematically augment the original XCodeEval and XLCoST datasets. For each source instance, we generate 2–3 multi-semantic augmented samples, resulting in a large-scale dataset comprising 309,212 C++ samples and 311,890 Java samples. Test Dataset. We evaluate our approach on the cross-lingual version of the HumanEval-X [33] benchmark suite, which consists of 164 distinct programming challenges. Each task is accompanied by a validated unit test harness and a reference implementation, enabling rigorous in terms of functional correctness and semantic consistency. Although HumanEval-X originates from code generation benchmarks, its cross-lingual setting provides functionally equivalent implementations and executable test suites, enabling reliable evaluation of semantic equivalence in code translation. 3.2

Baselines

LLM baselines. To investigate the performance boost provided by Multisage across various LLM parameter scales, we selected models spanning the current mainstream parameter ranges. Specifically, we chose DeepSeek-V3 [34], GPT-4 Turbo [35], and Qwen-Plus [36] to represent HP-LLMs. Qwen2.5-Coder-Instruct-33B [37] and StarCoder2-15B [38] 3 4

https://codeforces.com/ https://www.geeksforgeeks.org/

A PREPRINT - J UNE 11, 2026

were selected as MS-LLM baselines. Finally, StarCoder2-7B and Qwen2.5-Coder-7B serve as our baselines for ℓLMs. This selection enables a systematic evaluation of Multisage’s generalization capability across different model scales. Specialized code translation baselines. To compare Multisage with established code translation techniques, we select four representative methods covering different translation paradigms: (1) TransCoder [4], which represents a Transformer-based neural machine translation approach; (2) DOBF [39], a deobfuscation-based structured translation method designed to preserve program semantics and structure; (3) TransCoder-ST [15], which incorporates structured information such as AST to guide the translation process; (4) TransCoder-IR [40], which employs an intermediate representation as a translation bridge to enhance semantic preservation; and (5) INTERTRANS [41], which introduces intermediate languages as transitive bridges to facilitate cross-language translation by decomposing the translation process into multi-step transformations, and is implemented on top of the StarCoder2-15B model. Semantic Augmentation Capability Baselines. To assess the effectiveness of the proposed Multi-Semantic Augmentation Module (M2) and examine the role of specialized augmentation models, we select state-of-the-art HP-LLMs as auxiliary baselines, including DeepSeek-V3, GPT-4 Turbo, and Qwen-Plus. We evaluate the ability of these generalpurpose LLMs to directly generate semantic constraints, such as code summaries and unit tests, under zero-shot or few-shot prompting. Their generated constraints are then compared with those produced by the specialized M2 model in terms of accuracy, executability, and robustness. These baselines are introduced to support a dedicated evaluation of semantic augmentation quality in subsequent experiments. 3.3

Evaluation Metrics

Code Translation Success Rate. The Code Translation Success Rate measures the correctness of translated code in terms of executability and functional equivalence. We perform rigorous functional verification using the integrated unit test suite provided by the HumanEval-X benchmark. A translation is considered successful only if the generated target code passes all corresponding test cases, indicating that its functional behavior is consistent with the reference implementation. Given that the primary objective of code translation is to ensure executability and functional correctness, we do not treat purely static similarity-based metrics as the main evaluation criterion. Prior studies have shown that relying solely on static similarity measures can be misleading, as models may achieve high scores while producing code that fails to compile or execute correctly. Accordingly, we adopt execution-based functional validation as the primary metric, and only incorporate structure- and data-flow–aware static metrics as complementary analysis tools. CodeBLEU. CodeBLEU [42] is a structure-aware evaluation metric designed for code translation tasks and is used to complement execution-based validation by characterizing semantic consistency at the implementation level. Unlike static metrics that rely solely on n-gram matching, CodeBLEU extends BLEU with AST matching and data-flow analysis, enabling it to partially capture consistency in structural organization, variable dependencies, and data propagation patterns between the source and translated code. In particular, the data-flow component can be regarded as an approximation of semantic consistency at the implementation level. It should be emphasized that CodeBLEU does not guarantee functional equivalence, but instead provides complementary insights into the structural and semantic alignment of translation results beyond execution outcomes. 3.4

Implementation Details

Multisage is primarily implemented in Python, utilizing the PyTorch deep learning framework and Hugging Face’s Transformer library for model construction and management. Multi-Semantic Data Augmentation. In the data construction phase of the Multi-Semantic Augmentation Module, we employ GPT-4 Turbo as a semantic generation agent to produce high-level semantic constraints, including unit tests and API information. This agent operates via carefully engineered prompts and an execution validation feedback loop to ensure the quality and diversity of the generated semantic constraints. Multi-Semantic Augmentation Model Training. We fine-tuned the Multi-Semantic Augmentation Model based on the configurations derived from [30] to facilitate multi-task learning. During the training process, we employed the Adam optimizer, setting the per-GPU batch size to 2, and aggregating the global batch size to 128. For the learning rate schedule, we set the initial learning rate to 2 × 10−4 and used a cosine annealing strategy with a warmup ratio of 3 × 10−2 , with the minimum learning rate set at 1 × 10−5 . For the fine-tuning strategy, we utilized the QLoRA INT4 quantization mode proposed in [30] and maintained a consistent fine-tuning parameter ratio of 2.52% with the original work. Furthermore, to ensure optimal convergence and generalization performance for each model, we implemented an Early Stopping strategy to determine the model’s termination point. 13

A PREPRINT - J UNE 11, 2026

All experiments were conducted on a multi-GPU server equipped with NVIDIA A6000 GPUs. During inference, Multisage operates without additional fine-tuning and relies on prompt-based semantic augmentation, with an optional lightweight repair step applied to failed translations. All experiments were executed with fixed random seeds to ensure reproducibility. 3.5

Research Question

To evaluate the effectiveness of the Multisage, we formulate the following research questions (RQs): RQ1: How does the Multisage improve the performance of LLM-based code translation and mitigate intervenable errors? We evaluate two usage modes: (1) direct augmentation, where Multisage is applied during initial translation, and (2) repair-based augmentation, where additional semantic guidance is injected only for initially failed translations to assess recovery capability. Performance is measured in terms of functional correctness, CodeBLEU, and error-type distribution shifts. RQ2: How does Multisage perform against state-of-the-art code translation baselines? We compare Multisage with specialized translation models and instruction-tuned (IT) LLMs under the same benchmark and evaluation metrics. RQ3: What is the quality of the semantic augmentation generated by Multisage? We assess semantic quality from three perspectives. (1) Intrinsic validity: We adopt a back-translation protocol in which generated semantics are used to reconstruct target-language implementations. The evaluation is reported using the BT-Pass@k metric, defined as the probability of recovering a functionally correct implementation. (2) Comparative efficacy: we compare Multisage-generated semantics with reasoning-based baselines such as CoT. (3) Generative quality: we directly contrast the semantic representations produced by Multisage and HP-LLMs under identical targets. RQ4: How do individual components of Multisage contribute to the overall translation performance? To address this question, we performed an ablation study to analyze and quantify the contribution of each component to the code translation task. By selectively removing key modules and examining the resulting performance changes, we isolate the distinct value that each component adds to the final generation quality. RQ5: How sensitive is Multisage to the threshold parameters in the semantic consistency calibration module? We analyze the sensitivity of three parameters, namely the similarity threshold δ, the majority-support ratio ρ, and the global consistency threshold τ , by varying each parameter independently while keeping the others fixed at their default values, and observe the resulting performance changes.

Results and Analysis

4.1

RQ1: How does the Multisage improve the performance of LLM-based code translation and mitigate intervenable errors?

Fig. 6 and Table 2 report the translation performance under three settings: vanilla prompting, Multisage, and Multisage (Repair). Across all evaluated models, Multisage consistently improves translation success rates over the vanilla setting. The gains are particularly pronounced for small and mid-scale models. For example, the success rate of StarCoder2-15B increases from 46.95% to 71.34%, while StarCoder2-7B improves from 14.02% to 31.10%. In addition to higher execution success rates, Multisage also improves CodeBLEU scores across all models, indicating better alignment in code structure and data-flow semantics. For instance, the CodeBLEU score of StarCoder2-15B increases from 30.86% to 42.88%. These results suggest that explicit semantic augmentation improves not only functional correctness but also the structural quality of generated code. The Multisage (Repair) setting provides an additional complementary mechanism. Instead of augmenting all translations, semantic guidance is selectively applied only to instances that fail during the initial generation. Although the overall success rate of Multisage (Repair) does not always exceed direct Multisage, it often achieves comparable or higher CodeBLEU scores. For weaker models, the repair setting can further improve the success rate beyond direct Multisage. 14

A PREPRINT - J UNE 11, 2026

Figure 6: Translation success rates under different Multisage settings.

For example, StarCoder2-7B increases from 31.10% under Multisage to 35.37% with Multisage (Repair), indicating that targeted semantic guidance can recover a subset of previously failed translations. To better understand how these improvements arise, we further analyze the distribution of translation errors before and after applying Multisage. The detailed error statistics are reported in Appendix D. Overall, errors related to dependency reasoning and data interpretation decrease substantially after semantic augmentation, particularly for small and mid-scale models. This observation suggests that many translation failures stem from missing or misinterpreted semantic constraints, which can be effectively mitigated through explicit semantic guidance. Meanwhile, model-specific errors remain relatively stable across settings, indicating that such failures are primarily determined by model capacity rather than the availability of semantic information. 4.2

RQ2: How does Multisage perform against state-of-the-art code translation baselines?

Table 3 compares Multisage with representative state-of-the-art code translation baselines under identical evaluation settings, including specialized neural translation models and instruction-tuned LLMs. Compared with specialized translation models, Multisage significantly improves execution success rates. In particular, Multisage (15B) achieves 71.34% success rate, surpassing the strongest baseline INTERTRANS (67.34%) as well as earlier approaches such as TransCoder and DOBF by a large margin. These results indicate that semantic reliability modeling provides more effective guidance for preserving functional correctness than prior structural or intermediaterepresentation–based methods. In terms of CodeBLEU, INTERTRANS achieves the highest score (69.47%), suggesting that its multi-step translation process is effective in preserving surface-level structural similarity. In contrast, Multisage achieves moderate but consistent improvements over instruction-tuned LLMs, increasing CodeBLEU from 28.79 to 34.51 at the 7B scale and from 41.73 to 42.88 at the 15B scale. This indicates that Multisage improves structural alignment while primarily focusing on functional correctness. When compared with instruction-tuned LLM baselines at the same model scale, Multisage consistently improves both success rate and CodeBLEU. At the 7B scale, the success rate increases from 38.11% to 46.95%, while at the 15B scale it improves substantially from 51.22% to 71.34%. These results demonstrate that Multisage enhances both functional correctness and semantic consistency beyond what can be achieved by instruction tuning alone. Overall, the results highlight a clear distinction between structural similarity and functional correctness. While some methods (e.g., INTERTRANS) achieve higher CodeBLEU scores, Multisage delivers superior execution performance, demonstrating the effectiveness of explicitly modeling semantic reliability in code translation. 15

A PREPRINT - J UNE 11, 2026

Table 2: Translation success rate and CodeBLEU under different settings. Success CodeBLEU Rate (%) (%)

Model

Setting

DeepSeek-V3