cross-language porting

This work addresses the limitation of existing programming evaluation benchmarks in distinguishing whether large language models rely on memorization or possess genuine algorithmic reasoning capabilities. To this end, the authors propose AlgoBench, a framework that systematically transforms classic competitive programming problems through structured constraint migration, automatically generating new problems whose original algorithmic logic is invalidated yet remain semantically traceable, thereby compelling models to move beyond reference solutions. AlgoBench introduces novel complexity-aware evaluation metrics—such as OPTT and TRAPRATE—that prioritize algorithmic correctness over mere functional implementation. Experimental results demonstrate a significant performance drop among mainstream large language models on AlgoBench, with most ostensibly “correct” solutions failing to meet required time or space complexity constraints, thereby exposing their limited capacity for adaptive algorithmic reasoning.

This work addresses the problem of deriving provably tight floating-point rounding error bounds for numerical programs featuring conditional branches, no loops, and mixed-precision arithmetic. Methodologically, it unifies the modeling of conditional control flow and precision heterogeneity via two novel quantitative metrics—“instability jumps” and “window width”—and integrates interval arithmetic, abstract interpretation, and precision-aware semantic modeling, augmented with abstraction-guided global optimization. Its key contribution is the first formal framework enabling joint, compositional analysis of conditional branching and mixed precision, achieving both high bound tightness and practical analysis efficiency. Experimental evaluation on standard benchmarks demonstrates significantly tighter error bounds compared to prior approaches. Furthermore, the framework successfully guides precision configuration—e.g., step size and search direction—in the conjugate gradient method, empirically validating its utility in supporting design-time trade-offs among accuracy, error bounds, and computational efficiency.

Existing code generation benchmarks overemphasize functional correctness while neglecting developers’ practical needs regarding code style, constraint adherence, and iterative refinement. Method: We introduce the first developer-preference-oriented, multilingual instruction-following benchmark, featuring a dual-scenario evaluation framework—“initial constraint satisfaction” and “subsequent instruction response”—covering Python, Java, and JavaScript. Built upon LiveBench tasks, it leverages high-quality automated translation and an end-to-end automated evaluation pipeline to assess models across syntax compliance, semantic consistency, constraint fidelity, and iterative modification capability. Contribution/Results: Our systematic evaluation reveals substantial cross-lingual and cross-task disparities in instruction-following performance among state-of-the-art large language models. The benchmark delivers a fine-grained, development-context-aware performance profile—significantly advancing beyond traditional correctness-centric metrics and better reflecting real-world coding workflows.

Floating-point computations exhibit inconsistent results across compilers—including cross-platform and cross-optimization-level settings—posing a severe threat to the reliability of numerical software. This paper introduces, for the first time, large language models (LLMs) into floating-point inconsistency detection, proposing a synergistic approach that integrates syntax-guided program generation with feedback-driven mutation to automatically synthesize floating-point programs with high inconsistency-triggering capability. The method enables systematic comparative testing across multiple compilers, optimization levels, and heterogeneous host-device environments. Experimental evaluation demonstrates that our approach detects over twice as many floating-point inconsistencies as state-of-the-art tools. Moreover, it is the first to systematically uncover deep real-valued discrepancies across architectures and compiler toolchains, significantly enhancing verifiability and robustness assurance for numerical software.

Compiler optimizations designed for sequential consistency (SC) may violate correctness when ported to weaker memory models such as total store ordering (TSO), posing safety risks in cross-model optimization reuse. Method: We propose the first syntactically constrained, globally applicable migratability criterion for SC-to-TSO optimization migration, formally linking migratability to triangular data races—identified as the fundamental obstacle to safe SC→TSO migration. We extend the criterion to the strong release-acquire (SRA) model and validate its generality. Our approach combines formal verification, memory model semantics analysis, and a refined classification of data races. Results: We rigorously characterize the safety boundary for SC→TSO optimization migration, establishing a verifiable and generalizable theoretical foundation. The criterion enables sound, automated assessment of optimization migratability across memory models, providing both theoretical guarantees and practical guidelines for compiler development.

This study addresses the limited capability of large language models (LLMs) in statically detecting floating-point errors in code by introducing InterFLOPBench, the first specialized benchmark comprising 90 C-language kernels and 1,130 test cases. The task is formulated as a multi-label classification problem encompassing six canonical categories of floating-point errors. The authors propose an evaluation framework based on multi-label F1-score and conduct a systematic assessment across 14 prominent LLMs. Results show that state-of-the-art models, such as Qwen3-32B and Gemini 2.5 Flash, achieve overall F1-scores exceeding 0.88, with explicit errors like division-by-zero detected at a rate of 0.8479. However, implicit errors—including underflow and cancellation—remain challenging, with recognition rates around 0.60–0.62, highlighting current limitations in LLMs’ understanding of complex numerical semantics.

This study addresses the limitations of aggregate pass rates in evaluating large language models on competitive programming by conducting a fine-grained failure analysis. We systematically assess GPT-4o and Claude Sonnet 4.6 on 315 Codeforces problems, introducing a balanced failure taxonomy spanning seven algorithmic categories and three difficulty levels. Through multi-dimensional attribution—including execution validation, ablation studies of zero-shot and chain-of-thought (CoT) prompting, and temperature control (T=0.2)—we uncover critical insights: CoT substantially reduces GPT-4o’s overall pass rate (from 46.0% to 36.8%), particularly degrading performance on greedy algorithms; while Claude demonstrates stronger logical reasoning under CoT (63.5% pass rate), it suffers a 244% increase in compilation errors. Over 70% of failures for both models stem from incorrect outputs, highlighting the pivotal influence of algorithm type and prompting strategy on model performance.

This work addresses the persistent gap in runtime efficiency between code translations generated by large language models (LLMs) and those written by humans—a limitation that is difficult to mitigate through prompt engineering alone. To bridge this gap, the authors propose SwiftTrans, a novel framework that first generates diverse translation candidates through multi-perspective exploration and then selects the optimal solution using a discrepancy-aware selection mechanism. The framework further incorporates hierarchical and ordinal guidance strategies to enhance performance. Notably, this study is the first to systematically balance both functional correctness and runtime efficiency in LLM-based code translation. The authors introduce SwiftBench, a new benchmark tailored for this dual objective, and demonstrate that SwiftTrans achieves consistent and significant improvements over existing methods across CodeNet, F2SBench, and SwiftBench.

This work addresses the challenge of accurately attributing floating-point numerical discrepancies introduced by compilers. To this end, it proposes BMOA, a diagnostic framework that systematically disentangles three dimensions of such deviations: baseline comparison relationships, compiler-induced mechanistic evidence, and precision consequences. Integrating rigorous floating-point semantics, local transformation analysis, cross-compiler comparisons, high-precision validation, and reproducibility testing, BMOA generates auditable and traceable attribution records while preserving ambiguous attributions when evidence is insufficient. Evaluation on six scientific computing kernels targeting the ARM64 platform yielded 1,276 attribution records and 162 mechanistic instances, revealing that the choice of baseline significantly influences diagnostic conclusions and demonstrating that compiler-introduced deviations do not necessarily entail actual precision loss.