Pith. sign in

REVIEW 4 major objections 7 minor 2 cited by

Can Large Language Models Understand Intermediate Representations in Compilers?

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

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

Pith's one-line read Large language models can parse compiler internal representations but consistently fail at instruction-level reasoning about control flow, loops, and execution.

desk verdict A useful, novel benchmark whose qualitative conclusion holds, but the CFG scoring is underspecified and needs re-analysis before the headline numbers are trusted. read the letter →

arxiv 2502.06854 v2 pith:7Y5E5DDV submitted 2025-02-07 cs.LG cs.AIcs.CL

Hailong Jiang , Jianfeng Zhu , Yao Wan , Bo Fang , Hongyu Zhang , Ruoming Jin , Qiang Guan This is my paper · ORCID
classification cs.LGcs.AIcs.CL
keywords compilerintermediaterepresentationLLVMIRlargelanguagemodelscontrolflowgraphdecompilationexecutionreasoningprogramcomprehensionempiricalevaluation
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

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

The reading

This paper asks whether large language models truly understand compiler intermediate representations (IRs), the low-level, instruction-based code that sits between source code and machine code. By testing six leading LLMs on four tasks—reconstructing control flow graphs, decompiling IR back to source, summarizing IR behavior, and predicting execution results—the authors find that models can recognize IR syntax and high-level patterns but consistently fail at instruction-level reasoning: they misread branches, mishandle loops, omit critical operations, and approximate execution rather than simulate it. If this is right, current LLMs are not reliable for compiler-level analysis or execution reasoning despite their strong performance on high-level source code.

What carries the argument

The evaluation framework is the central mechanism: 164 C++ functions from HumanEval are compiled with Clang to LLVM IR at four optimization levels (-O0 to -O3), and the models are prompted with expert meta-templates to perform four tasks. Structural understanding is measured by exact-match and partial-match accuracy of reconstructed control flow graphs against compiler-generated ground truth; syntactic and semantic understanding are measured by decompilation re-execution success and by BLEU, ROUGE-L, and METEOR scores against golden summaries; and execution reasoning is measured by assertion-level pass rates on whether predicted output states hold. This machinery operationalizes IR understanding into quantifiable behaviors, and the paper also analyzes graph density as a correlate of structural reconstruction success.

What would settle it

A concrete falsifier would be a model fine-tuned on IR execution traces (or using a control-flow-aware architecture) that scores near-perfectly on the same four tasks; alternatively, if human experts judged the low-BLEU summaries as semantically correct, the paper's semantic-gap conclusion would be weakened.

Watch

Extended reading notes

Core claim

The central claim is that LLM competence on compiler IRs is surface-level: the models parse IR syntax and identify high-level structures, but struggle with instruction-level reasoning, particularly with control flow, loop handling, and dynamic execution. The evidence includes GPT-4 completing all 164 control-flow-graph reconstructions but producing only 39 fully correct graphs, and execution-reasoning pass rates on IR being far below those on the equivalent source code for every model tested. The paper further observes that LLMs rely on heuristic reasoning—inferring behavior from function names or assertion patterns—rather than simulating instructions step by step, which leads to failures in nested conditions, loops, and multi-step transformations.

Load-bearing premise

The conclusions depend on the assumption that the four tasks and their scoring metrics actually measure IR understanding, rather than formatting compliance, lexical overlap, or the particular set of assertions chosen.

Editorial extensions

If this is right

  • If the central claim is correct, current LLM-based decompilers, vulnerability detectors, and binary-analysis tools should not be trusted for instruction-level correctness.
  • Fine-tuning LLMs on structured IR datasets with execution-trace supervision could narrow the gap between source-level and IR-level reasoning.
  • Control-flow-sensitive architectures, such as graph neural networks or hybrid LLM-plus-graph designs, may be necessary for tasks that require tracking branches and loops.
  • Performance on high-level source code does not transfer to IR reasoning, so evaluation of code models should include representation-aware benchmarks.
  • Chain-of-thought prompting alone does not overcome the execution-reasoning deficit, suggesting the limitation is deeper than prompt format.

Reading between the lines

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

  • A testable extension would be to fine-tune a model on IR execution traces and check whether control-flow and loop errors disappear; if they persist, the limitation is architectural rather than training-data-driven.
  • The heuristic-guessing failure mode suggests LLMs lack an operational semantics of computation, not just IR familiarity; this may extend to other low-level formal languages such as assembly or bytecode.
  • If the findings generalize to non-HumanEval IRs, they would imply that uncertainty-aware prompting (allowing models to say 'I don't know') could reduce confident but wrong execution predictions.
  • The density-dependent CFG performance hints that model selection for IR analysis could be guided by graph complexity metrics, a practical implication the paper leaves implicit.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

4 major / 7 minor

Summary. The paper reports an exploratory empirical study of six large language models (GPT-4, GPT-3, DeepSeek R1, Gemma 2, Llama 3.1, and Code Llama) on four tasks over LLVM intermediate representations compiled from HumanEval C++ programs at four optimization levels: CFG reconstruction, decompilation, code summarization, and execution reasoning. The central qualitative claim is that LLMs can parse IR syntax and identify high-level structures, but consistently struggle with instruction-level reasoning, especially control flow, loops, and dynamic execution. The authors conclude by recommending IR-specific fine-tuning and control-flow-sensitive architectures, and they release data and code at a public repository.

Significance. If the central claim is supported, this is a useful first systematic characterization of a practically important capability gap: LLMs that perform well on source code do not yet reliably understand compiler IRs at the instruction level. The study has real strengths: it uses external ground truth (LLVM-generated CFGs, original C++ programs, HumanEval assertions, and human-curated golden summaries), it covers four complementary tasks, it includes concrete case studies in Appendix F, and the public release of data and code supports reproducibility. The findings, if hardened, would be relevant to compiler tooling, program analysis, and the design of IR-specific model architectures. However, several load-bearing quantitative choices need to be strengthened before the claims are fully convincing.

major comments (4)
  1. [Section 3.5 (Task 1), Table 2] The CFG scoring procedure is underspecified. The manuscript never states whether model DOT output is matched by exact string comparison of nodes and edges, by label-normalized comparison, or by graph isomorphism. Since LLVM's -dot-cfg emits compiler-generated block names (e.g., entry, if.then) and the prompt demands 'exactly match', a model that produces a structurally correct CFG with different block names or a different edge order would be counted as incorrect. This is load-bearing for RQ1 and Finding 1, because the reported full/partial/loop/condition accuracies in Table 2 are the only quantitative evidence for the control-flow weakness claim. The authors must specify the matching algorithm and release the scoring code, and ideally re-report results under a label-insensitive, isomorphism-based comparison. In addition, the GPT-4 row of Table 2 ('16450 39 9 2') cannot be parsed into the six declared columns, preventing independent auditing of the results.
  2. [Section 4.1.1, Appendix E (Table 6)] Point estimates are reported without uncertainty. Most models are run only once; the only repetition data (DeepSeek R1, Table 6) shows full CFG accuracy varying from 53 to 60 across runs, which is not 'minimal variance' for a claim of model ranking. The comparison of raw counts (GPT-4: 39/164 vs DeepSeek R1: 57/77) also ignores dramatically different task-completion rates and is therefore misleading as a cross-model comparison. The authors should run all models multiple times, report rates with confidence intervals (or significance tests), and normalize by per-completed-task denominators in every cross-model comparison.
  3. [Section 3.5 (Task 3), Table 4, Appendix D] The summarization metrics are not validated as measures of semantic understanding. BLEU, ROUGE-L, and METEOR are computed against a rigidly templated golden summary, so lexical overlap can be inflated by echoing template phrases regardless of semantic correctness, while semantically correct paraphrases may score low. The 'high-quality summary (score >0.8)' threshold in Table 4 is introduced without justification. Before drawing Finding 4 about fine-grained semantic deficits from these scores, the authors should provide a human-evaluation sample or a semantic similarity metric and show that the threshold corresponds to human judgments.
  4. [Section 4.1.2, Figure 3] The density analysis is not quantitatively supported. The text states that 'graph density strongly correlates with LLM performance' and that 'higher-density CFGs ... GPT-4 and Gemma 2 succeed more often, while Llama 3.1 fails', but Figure 3 shows grouped averages without correlation coefficients, significance tests, or error bars on the accuracy axes, and the x-axis categories (e.g., 'GPT-4 only', 'GPT-4 × Gemma 2') are not defined. The authors should either provide a proper statistical analysis (e.g., logistic regression of success on density and model) or reframe this as a qualitative observation rather than a finding.
minor comments (7)
  1. [Throughout] The model names are inconsistent: the abstract and Section 3.2 refer to 'Llama 3', while Tables 2-5 and Appendix E use 'Llama 3.1'; please standardize. Also, GPT-3 is described as 'state-of-the-art', which is inaccurate in 2025 and may mislead readers.
  2. [Table 5] Table 5 is malformed: the GPT-4 row renders as '164 164 59118 102 44 0.36 0.72' and the column headers and values need to be reformatted. The definition of 'partial pass' should state clearly whether it is the number of tasks with at least one correct assertion or the total number of correctly predicted assertions across tasks.
  3. [Appendix B] The third bullet in Appendix B mentions 'DDG extraction, and symbolic execution' as tasks in which consistent failure patterns were observed, but no such tasks are reported anywhere in the paper; this is an internal inconsistency and should be removed or the tasks added.
  4. [Section 3.4, Appendix C] Section 3.4 says prompts were 'iteratively refined' across variants, but Appendix C only provides the final prompts; for reproducibility, the authors should list the variants tested and the criterion used to select the final prompts.
  5. [Figure 3] The figure caption and axes are confusing: the y-axis is labeled 'Density' but the bars are labeled 'Full CFG Con. Accuracy' and 'Node Construction Error', and the caption says error bars denote the density range per category. Please clarify what each bar represents and add proper axis titles.
  6. [Impact Statement] The Impact Statement says 'we do not explore advanced prompting techniques, which could affect performance', yet Section 3.4 and Appendix C describe chain-of-thought and few-shot prompting; please reconcile this apparent contradiction.
  7. [Section 4.3.2, Appendix F.4] The qualitative failure counts (e.g., '45 cases', '35 cases', '28 cases', '22 cases', '18 cases') are not accompanied by a coding protocol or inter-rater reliability, and the categories are not mutually exclusive; please report how these categories were assigned and whether the counts overlap.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the study evaluates LLMs against external compiler-generated and human-curated ground truth, with no fitted input later repackaged as a prediction.

full rationale

This paper is an empirical benchmark study, not a derivation. The central claims are about LLM performance on four IR tasks, and every measured quantity is compared against external ground truth: LLVM's -dot-cfg CFGs for Task 1, the original C++ programs and re-execution results for Task 2, human-curated golden summaries for Task 3, and HumanEval assertion outcomes for Task 4. There is no parameter fitted to a subset of the data that is later called a prediction, no quantity defined in terms of the quantity it is supposed to explain, and no uniqueness theorem or ansatz imported from the authors' prior work that forces the conclusions. The self-citations in Section 1 (Jiang et al., 2024a,b) merely motivate the relevance of IRs and do not carry any load-bearing step of the evaluation. The CFG scoring procedure is admittedly underspecified, and Table 2 is hard to audit, but that is a correctness or reproducibility concern about how the external ground truth was matched, not a circularity: the ground truth is still compiler-generated and independent of the model outputs. Consequently, the paper's negative findings about LLM IR understanding may be affected by evaluation artifacts, but they do not reduce by construction to the paper's own inputs. Under the stated rules, an honest finding is that no significant circularity is present.

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

This is an empirical study, so the ledger contains no fitted parameters that enter a derivation and no invented entities. The 0.8 threshold is a hand-chosen analysis cutoff. The load-bearing assumptions concern metric validity and dataset representativeness; the paper explicitly concedes the dataset limitation but does not empirically validate the metric assumptions.

free parameters (1)
  • High-quality summary score threshold = 0.8
    Hand-chosen cutoff used in Task 3 (Table 4) to count 'high-quality' summaries in BLEU, ROUGE-L, and METEOR. It is a descriptive analysis threshold, not a fitted model parameter, but it shapes the claim that high-quality summaries are rare.
assumptions (4)
  • domain assumption LLVM's -dot-cfg output is a correct and complete ground truth for control flow structure.
    Task 1 scores CFG reconstruction against compiler-generated graphs without independent verification of the ground truth (Section 3.5, Task 1; Appendix D).
  • domain assumption BLEU, ROUGE-L, and METEOR scores are meaningful proxies for the semantic quality of IR code summaries.
    Task 3 uses lexical-overlap metrics against templated golden references without human validation or discussion of their limitations for code text (Section 3.5, Task 3; Table 4).
  • domain assumption HumanEval-derived C++/LLVM IR programs are representative enough to support general conclusions about LLM IR comprehension.
    The study generalizes from 164 short benchmark programs at four optimization levels; the authors acknowledge this limitation in the Impact Statement and Appendix B.
  • domain assumption The HumanEval assertions constitute a correct execution oracle for Task 4.
    Execution reasoning is scored against benchmark assertions; any error in the C++ translation or the assertions themselves would propagate to the reported pass rates (Sections 3.3 and 3.5, Task 4).

how reviews work

0 comments
Cite this review

Pith. "Pith review of Can Large Language Models Understand Intermediate Representations in Compilers?." pith.science (2026). https://pith.science/paper/7Y5E5DDV

@misc{pith2026250206854,
  author       = {Pith},
  title        = {Pith review of: Can Large Language Models Understand Intermediate Representations in Compilers?},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/7Y5E5DDV}},
  note         = {Machine review of arXiv:2502.06854}
}
read the original abstract

Intermediate Representations (IRs) play a critical role in compiler design and program analysis, yet their comprehension by Large Language Models (LLMs) remains underexplored. In this paper, we present an explorative empirical study evaluating the capabilities of six state-of-the-art LLMs: GPT-4, GPT-3, DeepSeek, Gemma 2, Llama 3, and Code Llama, in understanding IRs. Specifically, we assess model performance across four core tasks: control flow graph reconstruction, decompilation, code summarization, and execution reasoning. While LLMs exhibit competence in parsing IR syntax and identifying high-level structures, they consistently struggle with instruction-level reasoning, especially in control flow reasoning, loop handling, and dynamic execution. Common failure modes include misinterpreting branching instructions, omitting critical operations, and relying on heuristic reasoning rather than precise instruction-level logic. Our findings highlight the need for IR-specific enhancements in LLM design. We recommend fine-tuning on structured IR datasets and integrating control-flow-sensitive architectures to improve model effectiveness. All experimental data and source code are publicly available at

Figures

Figures reproduced from arXiv: 2502.06854 by the authors.

Figure 1
Figure 1. Overview of our evaluation framework for assessing LLM understanding of IRs across four tasks. struct CFGs from IRs (RQ1). We evaluate the structural understanding capabilities of LLMs, which are essential for program analysis and compiler optimization. To answer this RQ, Task 1 is designed to prompt LLMs to output CFG in DOT format based on a function’s LLVM IR. We further examine whether LLMs understand the syntax… view at source ↗
Figure 2
Figure 2. Illustration of LLVM IR hierarchical structure. and enable custom compiler passes [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. Density metrics comparing Complete CFG Accuracy vs. Node Construction Error. pared with compiler-generated ground truth using metrics including full and partial CFG accuracy, as well as cor￾rectness of loop and conditional edges [PITH_FULL_IMAGE:figures/full_fig_p005_3.png] view at source ↗
Figures from the paper (4 more)
Figure 4
Figure 4. Figure 4: An example of DeepSeek’s step-by-step reasoning and DOT output for control flow graph (CFG) generation from LLVM IR. Original source code 1 for (int i=0; i<num.length();i++) 2 if(find(key.begin(), key.end (), num(i) != key.end)) out+=1; Code from decompilation 1 for (s…
Figure 5
Figure 5. Figure 5: An example of Re-execution Mismatch from GPT-4. 18 [PITH_FULL_IMAGE:figures/full_fig_p018_5.png]
Figure 6
Figure 6. Figure 6: illustrates the LLVM Intermediate Representation (IR) of the truncate number function, which extracts the decimal part of a floating-point number [PITH_FULL_IMAGE:figures/full_fig_p019_6.png]
Figure 7
Figure 7. Figure 7: An example of source code C++. assert (search({5, 5, 5, 5, 1}) == 1); Expected behavior: The function should find the greatest integer with a frequency greater than or equal to its value. Example (CPP 121) as shown in [PITH_FULL_IMAGE:figures/full_fig_p021_7.png]

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 2 Pith papers

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

  1. Can Large Language Models Recover Semantic Optimization Opportunities That Compilers Miss?

    cs.PL 2026-08 conditional novelty 6.0 of 10

    On the new SeGaBench benchmark, the strongest of five LLMs recovered compiler-missed optimization semantics and produced validated, speedup-delivering code changes in a large majority of cases.

  2. Position Paper: Programming Language Techniques for Bridging LLM Code Generation Semantic Gaps

    cs.SE 2025-07 unverdicted novelty 2.0 of 10

    A position paper arguing that PL techniques, especially formal verification and structure-aware representations, should be deeply integrated into LLM code generation.

Reference graph

Works this paper leans on

70 extracted references · 37 canonical work pages · cited by 2 Pith papers

  1. [1]

    write newline

    " write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 global.max substring 't := if while FUNCTION format.date year duplicate empty "emp...

  2. [2]

    Malware detection using assembly code and control flow graph optimization

    Anju, S., Harmya, P., Jagadeesh, N., and Darsana, R. Malware detection using assembly code and control flow graph optimization. In Proceedings of the 1st Amrita ACM-W Celebration on Women in Computing in India, pp.\ 1--4. 2010

    work page 2010

  3. [3]

    Claude 3 model, 2024

    Anthropic. Claude 3 model, 2024. Available at https://www.anthropic.com/product

    work page 2024

  4. [4]

    Armengol-Estap \'e , J., Woodruff, J., Cummins, C., and O'Boyle, M. F. Slade: A portable small language model decompiler for optimized assembly. In 2024 IEEE/ACM International Symposium on Code Generation and Optimization (CGO), pp.\ 67--80. IEEE, 2024

    work page 2024

  5. [5]

    S., and Hoefler, T

    Ben-Nun, T., Jakobovits, A. S., and Hoefler, T. Neural code comprehension: A learnable representation of code semantics. Advances in neural information processing systems, 31, 2018

    work page 2018

  6. [6]

    Translating embeddings for modeling multi-relational data

    Bordes, A., Usunier, N., Garcia-Duran, A., Weston, J., and Yakhnenko, O. Translating embeddings for modeling multi-relational data. Advances in neural information processing systems, 26, 2013

    work page 2013

  7. [7]

    Compiler-based graph representations for deep learning models of code

    Brauckmann, A., Goens, A., Ertel, S., and Castrillon, J. Compiler-based graph representations for deep learning models of code. In Proceedings of the 29th International Conference on Compiler Construction, pp.\ 201--211, 2020

    work page 2020

  8. [8]

    Brown, T. B., Mann, B., Ryder, N., Subbiah, M., Kaplan, J., Dhariwal, P., Neelakantan, A., Shyam, P., Sastry, G., Askell, A., Agarwal, S., Herbert-Voss, A., Krueger, G., Henighan, T., Child, R., Ramesh, A., Ziegler, D. M., Wu, J., Winter, C., Hesse, C., Chen, M., Sigler, E., Litwin, M., Gray, S., Chess, B., Clark, J., Berner, C., McCandlish, S., Radford, ...

    arXiv 2005

Show all 70 references
  1. [9]

    Chen, M., Tworek, J., Jun, H., Yuan, Q., Pinto, H. P. D. O., Kaplan, J., Edwards, H., Burda, Y., Joseph, N., Brockman, G., et al. Evaluating large language models trained on code. arXiv preprint arXiv:2107.03374, 2021

    2021 arXiv

  2. [10]

    Intermediate representation: The increasing significance of intermediate representations in compilers

    Chow, F. Intermediate representation: The increasing significance of intermediate representations in compilers. Queue, 11 0 (10): 0 30--37, 2013

    2013

  3. [11]

    Graph neural networks for vulnerability detection: A counterfactual explanation

    Chu, Z., Wan, Y., Li, Q., Wu, Y., Zhang, H., Sui, Y., Xu, G., and Jin, H. Graph neural networks for vulnerability detection: A counterfactual explanation. In Proceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis, pp.\ 389--401, 2024

    2024

  4. [12]

    Church, K. W. Word2vec. Natural Language Engineering, 23 0 (1): 0 155--162, 2017

    2017

  5. [13]

    Faser: Binary code similarity search through the use of intermediate representations

    Collyer, J., Watson, T., and Phillips, I. Faser: Binary code similarity search through the use of intermediate representations. arXiv.org, 2023. doi:10.48550/arxiv.2310.03605

    2023 doi arXiv

  6. [14]

    V., Ben-Nun, T., Hoefler, T., O’Boyle, M

    Cummins, C., Fisches, Z. V., Ben-Nun, T., Hoefler, T., O’Boyle, M. F., and Leather, H. Programl: A graph-based program representation for data flow analysis and compiler optimizations. In International Conference on Machine Learning, pp.\ 2244--2253. PMLR, 2021

    2021

  7. [15]

    Meta large language model compiler: Foundation models of compiler optimization

    Cummins, C., Seeker, V., Grubisic, D., Roziere, B., Gehring, J., Synnaeve, G., and Leather, H. Meta large language model compiler: Foundation models of compiler optimization. arXiv preprint arXiv:2407.02524, 2024

    2024 arXiv

  8. [16]

    and Lavie, A

    Denkowski, M. and Lavie, A. Meteor universal: Language specific translation evaluation for any target language. In Proceedings of the ninth workshop on statistical machine translation, pp.\ 376--380, 2014

    2014

  9. [18]

    Bert: Pre-training of deep bidirectional transformers for language understanding

    Devlin, J., Chang, M.-W., Lee, K., and Toutanova, K. Bert: Pre-training of deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805, 2018

    2018 arXiv

  10. [19]

    A framework for cfg-based static program analysis of ada programs

    Fechete, R., Kienesberger, G., and Blieberger, J. A framework for cfg-based static program analysis of ada programs. In Reliable Software Technologies--Ada-Europe 2008: 13th Ada-Europe International Conference on Reliable Software Technologies, Venice, Italy, June 16-20, 2008....

    2008

  11. [20]

    Codebert: A pre-trained model for programming and natural languages

    Feng, Z., Guo, D., Tang, D., Duan, N., Feng, X., Gong, M., Shou, L., Qin, B., Liu, T., Jiang, D., et al. Codebert: A pre-trained model for programming and natural languages. arXiv preprint arXiv:2002.08155, 2020

    2002 arXiv

  12. [21]

    Cross-language binary-source code matching with intermediate representations

    Gui, Y., Wan, Y., Zhang, H., Huang, H., Sui, Y., Xu, G., Shao, Z., and Jin, H. Cross-language binary-source code matching with intermediate representations. In 2022 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER), pp.\ 601--612. IEEE, 2022

    2022

  13. [22]

    Graphcodebert: Pre-training code representations with data flow

    Guo, D., Ren, S., Lu, S., Feng, Z., Tang, D., Liu, S., Zhou, L., Duan, N., Svyatkovskiy, A., Fu, S., et al. Graphcodebert: Pre-training code representations with data flow. arXiv preprint arXiv:2009.08366, 2020

    2009 arXiv

  14. [23]

    Unixcoder: Unified cross-modal pre-training for code representation

    Guo, D., Lu, S., Duan, N., Wang, Y., Zhou, M., and Yin, J. Unixcoder: Unified cross-modal pre-training for code representation. arXiv preprint arXiv:2203.03850, 2022

    2022 arXiv

  15. [24]

    Deepseek-coder: When the large language model meets programming--the rise of code intelligence

    Guo, D., Zhu, Q., Yang, D., Xie, Z., Dong, K., Zhang, W., Chen, G., Bi, X., Wu, Y., Li, Y., et al. Deepseek-coder: When the large language model meets programming--the rise of code intelligence. arXiv preprint arXiv:2401.14196, 2024

    2024 arXiv

  16. [25]

    Summarizing source code with heterogeneous syntax graph and dual position

    Guo, J., Liu, J., Liu, X., Wan, Y., and Li, L. Summarizing source code with heterogeneous syntax graph and dual position. Information Processing & Management, 60 0 (5): 0 103415, 2023

    2023

  17. [26]

    Pre-trained models: Past, present and future

    Han, X., Zhang, Z., Ding, N., Gu, Y., Liu, X., Huo, Y., Qiu, J., Yao, Y., Zhang, A., Zhang, L., et al. Pre-trained models: Past, present and future. AI Open, 2: 0 225--250, 2021

    2021

  18. [27]

    Happa: A modular platform for hpc application resilience analysis with llms embedded

    Jiang, H., Zhu, J., Fang, B., Barker, K., Chen, C., Jin, R., and Guan, Q. Happa: A modular platform for hpc application resilience analysis with llms embedded. In 2024 43rd International Symposium on Reliable Distributed Systems (SRDS), pp.\ 40--51. IEEE, 2024 a

    2024

  19. [28]

    Investigating resilience of loops in hpc programs: A semantic approach with llms

    Jiang, H., Zhu, J., Fang, B., Chen, C., and Guan, Q. Investigating resilience of loops in hpc programs: A semantic approach with llms. In 2024 IEEE High Performance Extreme Computing Conference (HPEC), pp.\ 1--10. IEEE, 2024 b

    2024

  20. [29]

    A survey on large language models for code generation

    Jiang, J., Wang, F., Shen, J., Kim, S., and Kim, S. A survey on large language models for code generation. arXiv preprint arXiv:2406.00515, 2024 c

    2024 arXiv

  21. [30]

    and Adve, V

    Lattner, C. and Adve, V. LLVM: a compilation framework for lifelong program analysis & transformation. In CGO, CGO '04, 2004

    2004

  22. [31]

    B., Zi, Y., Muennighoff, N., Kocetkov, D., Mou, C., Marone, M., Akiki, C., Li, J., Chim, J., et al

    Li, R., Allal, L. B., Zi, Y., Muennighoff, N., Kocetkov, D., Mou, C., Marone, M., Akiki, C., Li, J., Chim, J., et al. Starcoder: may the source be with you! arXiv preprint arXiv:2305.06161, 2023

    2023 arXiv

  23. [32]

    Rouge: A package for automatic evaluation of summaries

    Lin, C.-Y. Rouge: A package for automatic evaluation of summaries. In Text summarization branches out, pp.\ 74--81, 2004

    2004

  24. [33]

    S., Wang, Y., and Zhang, L

    Liu, J., Xia, C. S., Wang, Y., and Zhang, L. Is your code generated by chatgpt really correct? rigorous evaluation of large language models for code generation. Advances in Neural Information Processing Systems, 36: 0 21558--21572, 2023 a

    2023

  25. [34]

    Pre-train, prompt, and predict: A systematic survey of prompting methods in natural language processing

    Liu, P., Yuan, W., Fu, J., Jiang, Z., Hayashi, H., and Neubig, G. Pre-train, prompt, and predict: A systematic survey of prompting methods in natural language processing. ACM Computing Surveys, September 2022. URL https://arxiv.org/abs/2107.13586

    2022 arXiv

  26. [35]

    Pre-train, prompt, and predict: A systematic survey of prompting methods in natural language processing

    Liu, P., Yuan, W., Fu, J., Jiang, Z., Hayashi, H., and Neubig, G. Pre-train, prompt, and predict: A systematic survey of prompting methods in natural language processing. ACM Computing Surveys, 55 0 (9): 0 1--35, 2023 b

    2023

  27. [36]

    Unveiling code pre-trained models: Investigating syntax and semantics capacities

    Ma, W., Liu, S., Zhao, M., Xie, X., Wang, W., Hu, Q., Zhang, J., and Liu, Y. Unveiling code pre-trained models: Investigating syntax and semantics capacities. ACM Transactions on Software Engineering and Methodology

  28. [37]

    Lms: Understanding code syntax and semantics for code analysis

    Ma, W., Liu, S., Lin, Z., Wang, W., Hu, Q., Liu, Y., Zhang, C., Nie, L., Li, L., and Liu, Y. Lms: Understanding code syntax and semantics for code analysis. arXiv preprint arXiv:2305.12138, 2023

    2023 arXiv

  29. [38]

    Cross-language binary-source code matching based on rust and intermediate representation, 2023

    Mao, J., Tang, Z., and Rao, W. Cross-language binary-source code matching based on rust and intermediate representation, 2023

    2023

  30. [39]

    McConnell, C. D. Tree-based code optimization. University of Illinois at Urbana-Champaign, 1993

    1993

  31. [40]

    Efficient estimation of word representations in vector space

    Mikolov, T. Efficient estimation of word representations in vector space. arXiv preprint arXiv:1301.3781, 2013

    2013 arXiv

  32. [41]

    Fair: Flow type-aware pre-training of compiler intermediate representations

    Niu, C., Li, C., Ng, V., Lo, D., and Luo, B. Fair: Flow type-aware pre-training of compiler intermediate representations. In Proceedings of the 46th IEEE/ACM International Conference on Software Engineering, pp.\ 1--12, 2024

    2024

  33. [42]

    Gpt-4 technical report, 2023

    OpenAI. Gpt-4 technical report, 2023. URL https://openai.com/research/gpt-4

    2023

  34. [43]

    Bleu: a method for automatic evaluation of machine translation

    Papineni, K., Roukos, S., Ward, T., and Zhu, W.-J. Bleu: a method for automatic evaluation of machine translation. In Proceedings of the 40th annual meeting of the Association for Computational Linguistics, pp.\ 311--318, 2002

    2002

  35. [44]

    S., O'Brien, J., Cai, C

    Park, J. S., O'Brien, J., Cai, C. J., Morris, M. R., Liang, P., and Bernstein, M. S. Generative agents: Interactive simulacra of human behavior. In Proceedings of the 36th annual acm symposium on user interface software and technology, pp.\ 1--22, 2023

    2023

  36. [45]

    Ircoder: Intermediate representations make language models robust multilingual code generators

    Paul, I., Luo, J., Glavas, G., and Gurevych, I. Ircoder: Intermediate representations make language models robust multilingual code generators. arXiv.org, 2024. doi:10.48550/arxiv.2403.03894

    2024 doi arXiv

  37. [46]

    How could neural networks understand programs? In International Conference on Machine Learning, pp.\ 8476--8486

    Peng, D., Zheng, S., Li, Y., Ke, G., He, D., and Liu, T.-Y. How could neural networks understand programs? In International Conference on Machine Learning, pp.\ 8476--8486. PMLR, 2021

    2021

  38. [47]

    Pennington, J., Socher, R., and Manning, C. D. Glove: Global vectors for word representation. In Proceedings of the 2014 conference on empirical methods in natural language processing (EMNLP), pp.\ 1532--1543, 2014

    2014

  39. [48]

    Pre-trained models for natural language processing: A survey

    Qiu, X., Sun, T., Xu, Y., Shao, Y., Dai, N., and Huang, X. Pre-trained models for natural language processing: A survey. Science China technological sciences, 63 0 (10): 0 1872--1897, 2020

    2020

  40. [49]

    Language models are unsupervised multitask learners

    Radford, A., Wu, J., Child, R., Luan, D., Amodei, D., Sutskever, I., et al. Language models are unsupervised multitask learners. OpenAI blog, 1 0 (8): 0 9, 2019

    2019

  41. [50]

    C., Bahmann, H., and Sj \"a lander, M

    Reissmann, N., Meyer, J. C., Bahmann, H., and Sj \"a lander, M. Rvsdg: An intermediate representation for optimizing compilers. ACM Transactions on Embedded Computing Systems (TECS), 19 0 (6): 0 1--28, 2020

    2020

  42. [51]

    E., Adi, Y., Liu, J., Sauvestre, R., Remez, T., Rapin, J., Kozhevnikov, A., Evtimov, I., Bitton, J., Bhatt, M., Ferrer, C

    Rozière, B., Gehring, J., Gloeckle, F., Sootla, S., Gat, I., Tan, X. E., Adi, Y., Liu, J., Sauvestre, R., Remez, T., Rapin, J., Kozhevnikov, A., Evtimov, I., Bitton, J., Bhatt, M., Ferrer, C. C., Grattafiori, A., Xiong, W., Défossez, A., Copet, J., Azhar, F., Touvron, H., Mart...

    2024 arXiv

  43. [52]

    Polyhedral optimizations for a data-flow graph language

    Sb \^ rlea, A., Shirako, J., Pouchet, L.-N., and Sarkar, V. Polyhedral optimizations for a data-flow graph language. In International Workshop on Languages and Compilers for Parallel Computing, pp.\ 57--72. Springer, 2015

    2015

  44. [53]

    Llm4decompile: Decompiling binary code with large language models

    Tan, H., Luo, Q., Li, J., and Zhang, Y. Llm4decompile: Decompiling binary code with large language models. arXiv preprint arXiv:2403.05286, 2024

    2024 arXiv

  45. [54]

    Codegemma: Open code models based on gemma

    Team, C. Codegemma: Open code models based on gemma. arXiv preprint arXiv:2406.11409, 2024

    2024 arXiv

  46. [55]

    G., Hardin, C., Bhupatiraju, S., Hussenot, L., Mesnard, T., Shahriari, B., Ram \'e , A., et al

    Team, G., Riviere, M., Pathak, S., Sessa, P. G., Hardin, C., Bhupatiraju, S., Hussenot, L., Mesnard, T., Shahriari, B., Ram \'e , A., et al. Gemma 2: Improving open language models at a practical size. arXiv preprint arXiv:2408.00118, 2024

    2024 arXiv

  47. [56]

    Llama: Open and efficient foundation language models

    Touvron, H., Lavril, T., Izacard, G., Martinet, X., Lachaux, M.-A., Lacroix, T., Roziere, B., Goyal, N., Hambro, E., Azhar, F., Rodriguez, A., Joulin, A., Grave, E., Lample, G., and Jegou, H. Llama: Open and efficient foundation language models. arXiv preprint arXiv:2302.13971, 2023

    2023 arXiv

  48. [57]

    N., Kaiser, ., and Polosukhin, I

    Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A. N., Kaiser, ., and Polosukhin, I. Attention is all you need. Advances in neural information processing systems, 30, 2017

    2017

  49. [58]

    S., Upadrasta, R., and Srikant, Y

    VenkataKeerthy, S., Aggarwal, R., Jain, S., Desarkar, M. S., Upadrasta, R., and Srikant, Y. Ir2vec: Llvm ir based scalable program embeddings. ACM Transactions on Architecture and Code Optimization (TACO), 17 0 (4): 0 1--27, 2020

    2020

  50. [59]

    Deep learning for code intelligence: Survey, benchmark and toolkit

    Wan, Y., Bi, Z., He, Y., Zhang, J., Zhang, H., Sui, Y., Xu, G., Jin, H., and Yu, P. Deep learning for code intelligence: Survey, benchmark and toolkit. ACM Computing Surveys, 56 0 (12): 0 1--41, 2024

    2024

  51. [60]

    Wang, Y., Wang, W., Joty, S., and Hoi, S. C. Codet5: Identifier-aware unified pre-trained encoder-decoder models for code understanding and generation. arXiv preprint arXiv:2109.00859, 2021

    2021 arXiv

  52. [61]

    D., Bui, N

    Wang, Y., Le, H., Gotmare, A. D., Bui, N. D., Li, J., and Hoi, S. C. Codet5+: Open code large language models for code understanding and generation. arXiv preprint arXiv:2305.07922, 2023

    2023 arXiv

  53. [62]

    J., Utting, M., and Hayes, I

    Webb, B. J., Utting, M., and Hayes, I. J. A formal semantics of the graalvm intermediate representation. In International Symposium on Automated Technology for Verification and Analysis, pp.\ 111--126. Springer, 2021

    2021

  54. [63]

    V., Zhou, D., et al

    Wei, J., Wang, X., Schuurmans, D., Bosma, M., Xia, F., Chi, E., Le, Q. V., Zhou, D., et al. Chain-of-thought prompting elicits reasoning in large language models. Advances in neural information processing systems, 35: 0 24824--24837, 2022

    2022

  55. [64]

    K., Wang, H., Li, Z., Liu, Z., Wang, S., Tang, Q., Nie, S., and Wu, S

    Wong, W. K., Wang, H., Li, Z., Liu, Z., Wang, S., Tang, Q., Nie, S., and Wu, S. Refining decompiled c code with large language models. arXiv preprint arXiv:2310.06530, 2023

    2023 arXiv

  56. [65]

    Wu, Y., Wan, Y., Chu, Z., Zhao, W., Liu, Y., Zhang, H., Shi, X., and Yu, P. S. Can large language models serve as evaluators for code summarization? arXiv preprint arXiv:2412.01333, 2024

    2024 arXiv

  57. [66]

    Codecmr: Cross-modal retrieval for function-level binary source code matching

    Yu, Z., Zheng, W., Wang, J., Tang, Q., Nie, S., and Wu, S. Codecmr: Cross-modal retrieval for function-level binary source code matching. Advances in Neural Information Processing Systems, 33: 0 3872--3883, 2020

    2020

  58. [67]

    Java code clone detection by exploiting semantic and syntax information from intermediate code-based graph

    Yuan, D., Fang, S., Zhang, T., Xu, Z., and Luo, X. Java code clone detection by exploiting semantic and syntax information from intermediate code-based graph. IEEE Transactions on Reliability, 2023. doi:10.1109/TR.2022.3176922

    2023

  59. [68]

    X., Zhou, K., Li, J., Tang, T., Wang, X., Hou, Y., Min, Y., Zhang, B., Zhang, J., Dong, Z., et al

    Zhao, W. X., Zhou, K., Li, J., Tang, T., Wang, X., Hou, Y., Min, Y., Zhang, B., Zhang, J., Dong, Z., et al. A survey of large language models. arXiv preprint arXiv:2303.18223, 2023

    2023 arXiv

  60. [69]

    Codegeex: A pre-trained model for code generation with multilingual benchmarking on humaneval-x

    Zheng, Q., Xia, X., Zou, X., Dong, Y., Wang, S., Xue, Y., Wang, Z., Shen, L., Wang, A., Li, Y., Su, T., Yang, Z., and Tang, J. Codegeex: A pre-trained model for code generation with multilingual benchmarking on humaneval-x. In Proceedings of the 29th ACM SIGKDD Conference on K...

    2023

  61. [70]

    A method for software vulnerability detection based on improved control flow graph

    Zhou, M., Chen, J., Liu, Y., Ackah-Arthur, H., Chen, S., Zhang, Q., and Zeng, Z. A method for software vulnerability detection based on improved control flow graph. Wuhan University Journal of Natural Sciences, 24 0 (2): 0 149--160, 2019

    2019

  62. [71]

    Vulnerability localization based on intermediate code representation and feature fusion

    Zhu, C., Wei, R., Chen, L., Wu, T., Du, G., and Shi, G. Vulnerability localization based on intermediate code representation and feature fusion. The Computer Journal, 2024. doi:10.1093/comjnl/bxae041

    2024 doi

Pith tools

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