Log in

Relevant bibliographies by topics / Compilers / Journal articles

To see the other types of publications on this topic, follow the link: Compilers.

Journal articles on the topic 'Compilers'

Author: Grafiati

Published: 4 June 2021

Last updated: 25 July 2025

Create a spot-on reference in APA, MLA, Chicago, Harvard, and other styles

Select a source type:

Consult the top 50 journal articles for your research on the topic 'Compilers.'

Next to every source in the list of references, there is an 'Add to bibliography' button. Press on it, and we will generate automatically the bibliographic reference to the chosen work in the citation style you need: APA, MLA, Harvard, Chicago, Vancouver, etc.

You can also download the full text of the academic publication as pdf and read online its abstract whenever available in the metadata.

Browse journal articles on a wide variety of disciplines and organise your bibliography correctly.

1

Alfonseca, Enrique. "Writing a compilers compiler in APL." ACM SIGAPL APL Quote Quad 29, no. 3 (1999): 69–75. http://dx.doi.org/10.1145/327600.327620.

Full text

APA, Harvard, Vancouver, ISO, and other styles

2

Baldwin, Doug. "A compiler for teaching about compilers." ACM SIGCSE Bulletin 35, no. 1 (2003): 220–23. http://dx.doi.org/10.1145/792548.611974.

Full text

APA, Harvard, Vancouver, ISO, and other styles

3

KHARIN, I. A., and M. V. RASKATOVA. "ANALYSIS OF THE ALGORITHMS OF THE CONSTITUENT PARTS OF THE COMPILER AND ITS OPTIMIZATION." Computational Nanotechnology 10, no. 2 (2023): 26–35. http://dx.doi.org/10.33693/2313-223x-2023-10-2-26-35.

Full text

Abstract:

Program optimization arose as a response to the emergence of high-level programming languages, and includes special techniques and methods used in building compilers to produce sufficiently efficient object code. A combination of these techniques constituted in the past and are now an integral part of so-called optimizing compilers, the purpose of which is to create object code, saving computer resources such as processor time and memory. For modern supercomputers, the requirement to make proper use of hardware features is also added. In this context, issues related to compiler optimization de

APA, Harvard, Vancouver, ISO, and other styles

4

Zimmermann, Wolf, and Thilo Gaul. "On the Construction of Correct Compiler Back-Ends: An ASM-Approach." JUCS - Journal of Universal Computer Science 3, no. (5) (1997): 504–67. https://doi.org/10.3217/jucs-003-05-0504.

Full text

Abstract:

Existing works on the construction of correct compilers have at least one of the following drawbacks: (i) correct compilers do not compile into machine code of existing processors. Instead they compile into programs of an abstract machine which ignores limitations and properties of real-life processors. (ii) the code generated by correct compilers is orders of magnitudes slower than the code generated by unverified compilers. (iii) the considered source language is much less complex than real-life programming languages. This paper focuses on the construction of correct compiler backends which

APA, Harvard, Vancouver, ISO, and other styles

5

Liu, Changlan, Yingsong Zhang, Peng Zuo, and Peng Wang. "Compiler Identification with Divisive Analysis and Support Vector Machine." Symmetry 17, no. 6 (2025): 867. https://doi.org/10.3390/sym17060867.

Full text

Abstract:

Compilers play a crucial role in software development, as most software must be compiled into binaries before release. Analyzing the compiler version from binary files is of great importance in software reverse engineering, maintenance, traceability, and information security. In this work, we propose a novel framework for compiler version identification. Firstly, we generated 1000 C language source codes using CSmith and subsequently compiled them into 16,000 binary files using 16 distinct versions of compilers. The symmetric distribution of the dataset among different compiler versions may en

APA, Harvard, Vancouver, ISO, and other styles

6

Patrignani, Marco, and Deepak Garg. "Robustly Safe Compilation, an Efficient Form of Secure Compilation." ACM Transactions on Programming Languages and Systems 43, no. 1 (2021): 1–41. http://dx.doi.org/10.1145/3436809.

Full text

Abstract:

Security-preserving compilers generate compiled code that withstands target-level attacks such as alteration of control flow, data leaks, or memory corruption. Many existing security-preserving compilers are proven to be fully abstract, meaning that they reflect and preserve observational equivalence. Fully abstract compilation is strong and useful but, in certain cases, comes at the cost of requiring expensive runtime constructs in compiled code. These constructs may have no relevance for security, but are needed to accommodate differences between the source and target languages that fully ab

APA, Harvard, Vancouver, ISO, and other styles

7

Heidari, Sayed Moeid, and Alexey A. Paznikov. "Multipurpose Cloud-Based Compiler Based on Microservice Architecture and Container Orchestration." Symmetry 14, no. 9 (2022): 1818. http://dx.doi.org/10.3390/sym14091818.

Full text

Abstract:

Compilation often takes a long time, especially for large projects or when identifying better optimization options. Currently, compilers are mainly installed on local machines and used as standalone software. Despite the availability of several online compilers, they do not offer an efficient all-in-one package for private account management, command line interface (CLI), code advisors, and optimization techniques. Today, the widespread usage of Software as a Service (SaaS) is ever-growing, and compilers are not an exception. In this paper, we describe a symmetric approach to compilation and h

APA, Harvard, Vancouver, ISO, and other styles

8

Paraskevopoulou, Zoe, John M. Li, and Andrew W. Appel. "Compositional optimizations for CertiCoq." Proceedings of the ACM on Programming Languages 5, ICFP (2021): 1–30. http://dx.doi.org/10.1145/3473591.

Full text

Abstract:

Compositional compiler verification is a difficult problem that focuses on separate compilation of program components with possibly different verified compilers. Logical relations are widely used in proving correctness of program transformations in higher-order languages; however, they do not scale to compositional verification of multi-pass compilers due to their lack of transitivity. The only known technique to apply to compositional verification of multi-pass compilers for higher-order languages is parametric inter-language simulations (PILS), which is however significantly more complicated

APA, Harvard, Vancouver, ISO, and other styles

9

Geeson, Luke, James Brotherston, Wilco Dijkstra, et al. "Mix Testing: Specifying and Testing ABI Compatibility of C/C++ Atomics Implementations." Proceedings of the ACM on Programming Languages 8, OOPSLA2 (2024): 442–67. http://dx.doi.org/10.1145/3689727.

Full text

Abstract:

The correctness of complex software depends on the correctness of both the source code and the compilers that generate corresponding binary code. Compilers must do more than preserve the semantics of a single source file: they must ensure that generated binaries can be composed with other binaries to form a final executable. The compatibility of composition is ensured using an Application Binary Interface (ABI), which specifies details of calling conventions, exception handling, and so on. Unfortunately, there are no official ABIs for concurrent programs, so different atomics mappings, althoug

APA, Harvard, Vancouver, ISO, and other styles

10

Müller, Matthias S. "An OpenMP Compiler Benchmark." Scientific Programming 11, no. 2 (2003): 125–31. http://dx.doi.org/10.1155/2003/287461.

Full text

Abstract:

The purpose of this benchmark is to propose several optimization techniques and to test their existence in current OpenMP compilers. Examples are the removal of redundant synchronization constructs, effective constructs for alternative code and orphaned directives. The effectiveness of the compiler generated code is measured by comparing different OpenMP constructs and compilers. If possible, we also compare with the hand coded "equivalent" solution. Six out of seven proposed optimization techniques are already implemented in different compilers. However, most compilers implement only one or t

APA, Harvard, Vancouver, ISO, and other styles

11

Noor, Abdul Rafae, Dhruv Baronia, Akash Kothari, Muchen Xu, Charith Mendis, and Vikram S. Adve. "MISAAL: Synthesis-Based Automatic Generation of Efficient and Retargetable Semantics-Driven Optimizations." Proceedings of the ACM on Programming Languages 9, PLDI (2025): 1269–92. https://doi.org/10.1145/3729301.

Full text

Abstract:

Using program synthesis to select instructions for and optimize input programs is receiving increasing attention. However, existing synthesis-based compilers are faced by two major challenges that prohibit the deployment of program synthesis in production compilers: exorbitantly long synthesis times spanning several minutes and hours; and scalability issues that prevent synthesis of complex modern compute and data swizzle instructions, which have been found to maximize performance of modern tensor and stencil workloads. This paper proposes MISAAL, a synthesis-based compiler that employs a nove

APA, Harvard, Vancouver, ISO, and other styles

12

Hartel, Pieter H., Marc Feeley, Martin Alt, et al. "Benchmarking implementations of functional languages with ‘Pseudoknot’, a float-intensive benchmark." Journal of Functional Programming 6, no. 4 (1996): 621–55. http://dx.doi.org/10.1017/s0956796800001891.

Full text

Abstract:

AbstractOver 25 implementations of different functional languages are benchmarked using the same program, a floating-point intensive application taken from molecular biology. The principal aspects studied are compile time and execution time for the various implementations that were benchmarked. An important consideration is how the program can be modified and tuned to obtain maximal performance on each language implementation. With few exceptions, the compilers take a significant amount of time to compile this program, though most compilers were faster than the then current GNU C compiler (GCC

APA, Harvard, Vancouver, ISO, and other styles

13

Kwon, Jaeseong, Bongjun Jang, Juneyoung Lee, and Kihong Heo. "Optimization-Directed Compiler Fuzzing for Continuous Translation Validation." Proceedings of the ACM on Programming Languages 9, PLDI (2025): 627–50. https://doi.org/10.1145/3729275.

Full text

Abstract:

Incorrect compiler optimizations can lead to unintended program behavior and security vulnerabilities. However, the enormous size and complexity of modern compilers make it challenging to ensure the correctness of optimizations. The problem becomes more severe as compiler engineers continuously add new optimizations to improve performance and support new language features. In this paper, we propose Optimuzz, a framework to effectively detect incorrect optimization bugs in such continuously changing compilers. The key idea is to combine two complementary techniques: directed grey-box fuzzing an

APA, Harvard, Vancouver, ISO, and other styles

14

Bahr, Patrick, and Graham Hutton. "Beyond Trees: Calculating Graph-Based Compilers (Functional Pearl)." Proceedings of the ACM on Programming Languages 8, ICFP (2024): 370–94. http://dx.doi.org/10.1145/3674638.

Full text

Abstract:

Bahr and Hutton recently developed an approach to compiler calculation that allows a wide range of compilers to be derived from specifications of their correctness. However, a limitation of the approach is that it results in compilers that produce tree-structured code. By contrast, realistic compilers produce code that is essentially graph-structured, where the edges in the graph represent jumps that transfer the flow of control to other locations in the code. In this article, we show how their approach can naturally be adapted to calculate compilers that produce graph-structured code, without

APA, Harvard, Vancouver, ISO, and other styles

15

Chowdhary, K. R., Rajendra Purohit, and Sunil Dutt Purohit. "Source-to-source translation for code-optimization." Journal of Information and Optimization Sciences 44, no. 3 (2023): 407–16. http://dx.doi.org/10.47974/jios-1350.

Full text

Abstract:

Multi-core design intends to serve a large market with user-oriented and highproductivity management as opposed to any other parallel system. Small numbers of processors, a frequent feature of current multi-core systems, are ideal for future generation of CPUs, where automated parallelization succeeds on shared space architectures. The multi-core compiler optimization platform CETUS (high-level to high-level compiler) offers initiates automatic parallelization in compiled programmes. This compiler’s infrastructure is built with C programmes in mind and is user-friendly and simple to use. It of

APA, Harvard, Vancouver, ISO, and other styles

16

Mahajan, Gunjali, Tejashri Bhargav, Anjali Sharma, Rekha Thorat, and Kavita Patil. "Cross Compilers." IJARCCE 6, no. 3 (2017): 185–89. http://dx.doi.org/10.17148/ijarcce.2017.6339.

Full text

APA, Harvard, Vancouver, ISO, and other styles

17

Grybkauskas, Saulius, Vilius Ivanauskas, and Aurimas Švedas. "Compilers’ Foreword." Lithuanian Historical Studies 15, no. 1 (2010): 1. http://dx.doi.org/10.30965/25386565-01501001.

Full text

APA, Harvard, Vancouver, ISO, and other styles

18

Wolfe, Michael. "Parallelizing compilers." ACM Computing Surveys 28, no. 1 (1996): 261–62. http://dx.doi.org/10.1145/234313.234417.

Full text

APA, Harvard, Vancouver, ISO, and other styles

19

Brustad, Robert J., Thomas E. Deeter, and Charles J. Hardy. "Digest Compilers." Journal of Sport and Exercise Psychology 11, no. 3 (1989): 245–50. http://dx.doi.org/10.1123/jsep.11.3.245.

Full text

APA, Harvard, Vancouver, ISO, and other styles

20

Li, Yichen, Dongwei Xiao, Zhibo Liu, Qi Pang, and Shuai Wang. "Metamorphic Testing of Secure Multi-party Computation (MPC) Compilers." Proceedings of the ACM on Software Engineering 1, FSE (2024): 1216–37. http://dx.doi.org/10.1145/3643781.

Full text

Abstract:

The demanding need to perform privacy-preserving computations among multiple data owners has led to the prosperous development of secure multi-party computation (MPC) protocols. MPC offers protocols for parties to jointly compute a function over their inputs while keeping those inputs private. To date, MPC has been widely adopted in various real-world, privacy-sensitive sectors, such as healthcare and finance. Moreover, to ease the adoption of MPC, industrial and academic MPC compilers have been developed to automatically translate programs describing arbitrary MPC procedures into low-level MP

APA, Harvard, Vancouver, ISO, and other styles

21

Feng, Jing Ge, Ye Ping He, and Qiu Ming Tao. "Evaluation of Compilers’ Capability of Automatic Vectorization Based on Source Code Analysis." Scientific Programming 2021 (November 30, 2021): 1–15. http://dx.doi.org/10.1155/2021/3264624.

Full text

Abstract:

Automatic vectorization is an important technique for compilers to improve the parallelism of programs. With the widespread usage of SIMD (Single Instruction Multiple Data) extensions in modern processors, automatic vectorization has become a hot topic in the research of compiler techniques. Accurately evaluating the effectiveness of automatic vectorization in typical compilers is quite valuable for compiler optimization and design. This paper evaluates the effectiveness of automatic vectorization, analyzes the limitation of automatic vectorization and the main causes, and improves the automat

APA, Harvard, Vancouver, ISO, and other styles

22

Serrano, Manuel. "Of JavaScript AOT compilation performance." Proceedings of the ACM on Programming Languages 5, ICFP (2021): 1–30. http://dx.doi.org/10.1145/3473575.

Full text

Abstract:

The fastest JavaScript production implementations use just-in-time (JIT) compilation and the vast majority of academic publications about implementations of dynamic languages published during the last two decades focus on JIT compilation. This does not imply that static compilers (AoT) cannot be competitive; as comparatively little effort has been spent creating fast AoT JavaScript compilers, a scientific comparison is lacking. This paper presents the design and implementation of an AoT JavaScript compiler, focusing on a performance analysis. The paper reports on two experiments, one based on

APA, Harvard, Vancouver, ISO, and other styles

23

Ebresafe, Oghenevwogaga, Ian Zhao, Ende Jin, Arthur Bright, Charles Jian, and Yizhou Zhang. "Certified Compilers à la Carte." Proceedings of the ACM on Programming Languages 9, PLDI (2025): 372–95. https://doi.org/10.1145/3729261.

Full text

Abstract:

Certified compilers are complex software systems. Like other large systems, they demand modular, extensible designs. While there has been progress in extensible metatheory mechanization, scaling extensibility and reuse to meet the demands of full compiler verification remains a major challenge. We respond to this challenge by introducing novel expressive power to a proof language. Our language design equips the Rocq prover with an extensibility mechanism inspired by the object-oriented ideas of late binding, mixin composition, and family polymorphism. We implement our design as a plugin for Ro

APA, Harvard, Vancouver, ISO, and other styles

24

Yang, Chenyuan, Yinlin Deng, Runyu Lu, et al. "WhiteFox: White-Box Compiler Fuzzing Empowered by Large Language Models." Proceedings of the ACM on Programming Languages 8, OOPSLA2 (2024): 709–35. http://dx.doi.org/10.1145/3689736.

Full text

Abstract:

Compiler correctness is crucial, as miscompilation can falsify program behaviors, leading to serious consequences over the software supply chain. In the literature, fuzzing has been extensively studied to uncover compiler defects. However, compiler fuzzing remains challenging: Existing arts focus on black- and grey-box fuzzing, which generates test programs without sufficient understanding of internal compiler behaviors. As such, they often fail to construct test programs to exercise intricate optimizations. Meanwhile, traditional white-box techniques, such as symbolic execution, are computati

APA, Harvard, Vancouver, ISO, and other styles

25

Livinskii, Vsevolod, Dmitry Babokin, and John Regehr. "Fuzzing Loop Optimizations in Compilers for C++ and Data-Parallel Languages." Proceedings of the ACM on Programming Languages 7, PLDI (2023): 1826–47. http://dx.doi.org/10.1145/3591295.

Full text

Abstract:

Compilers are part of the foundation upon which software systems are built; they need to be as correct as possible. This paper is about stress-testing loop optimizers; it presents a major reimplementation of Yet Another Random Program Generator (YARPGen), an open-source generative compiler fuzzer. This new version has found 122 bugs, both in compilers for data-parallel languages, such as the Intel® Implicit SPMD Program Compiler and the Intel® oneAPI DPC++ compiler, and in C++ compilers such as GCC and Clang/LLVM. The first main contribution of our work is a novel method for statically avoidin

APA, Harvard, Vancouver, ISO, and other styles

26

Xiao, Dongwei, Zhibo Liu, Yuanyuan Yuan, Qi Pang, and Shuai Wang. "Metamorphic Testing of Deep Learning Compilers." ACM SIGMETRICS Performance Evaluation Review 50, no. 1 (2022): 65–66. http://dx.doi.org/10.1145/3547353.3522655.

Full text

Abstract:

The prosperous trend of deploying deep neural network (DNN) models to diverse hardware platforms has boosted the development of deep learning (DL) compilers. DL compilers take high-level DNN model specifications as input and generate optimized DNN executables for diverse hardware architectures like CPUs, GPUs, and hardware accelerators. We introduce MT-DLComp, a metamorphic testing framework specifically designed for DL compilers to uncover erroneous compilations. Our approach leverages deliberately-designed metamorphic relations (MRs) to launch semantics-preserving mutations toward DNN models

APA, Harvard, Vancouver, ISO, and other styles

27

Theodoridis, Theodoros, and Zhendong Su. "Refined Input, Degraded Output: The Counterintuitive World of Compiler Behavior." Proceedings of the ACM on Programming Languages 8, PLDI (2024): 671–91. http://dx.doi.org/10.1145/3656404.

Full text

Abstract:

To optimize a program, a compiler needs precise information about it. Significant effort is dedicated to improving the ability of compilers to analyze programs, with the expectation that more information results in better optimization. But this assumption does not always hold: due to unexpected interactions between compiler components and phase ordering issues, sometimes more information leads to worse optimization. This can lead to wasted research and engineering effort whenever compilers cannot efficiently leverage additional information. In this work, we systematically examine the extent to

APA, Harvard, Vancouver, ISO, and other styles

28

Vishakha, Agrawal. "Demystifying Deep Learning Compiler Optimizations for Training and Inference." Journal of Advances in Developmental Research 12, no. 2 (2021): 1–9. https://doi.org/10.5281/zenodo.14551855.

Full text

Abstract:

Deep learning has achieved tremendous success in recent years, powering many artificial intelligence applications. However, deep learning models are computationally intensive to train, requiring massive amounts of data and compute resources. Once trained, deep learning models need to be deployed for inference to make predictions on new data. Hardware used for training differs from hardware used for inference. Deep learning compilers have revolutionized the field of artificial intelligence by optimizing the performance of deep learning models on various hardware platforms. In the current landsc

APA, Harvard, Vancouver, ISO, and other styles

29

Solé, Marc, and Leonidas Kosmidis. "Compiler Support for an AI-oriented SIMD Extension of a Space Processor." ACM SIGAda Ada Letters 42, no. 1 (2022): 95–99. http://dx.doi.org/10.1145/3577949.3577968.

Full text

Abstract:

In this on going research paper, we present our work on the compiler support for an AI-oriented SIMD Extension, called SPARROW. The SPARROW hardware design has been developed during a recently defended, awardwinning Master Thesis and is targeting Cobham Gaisler's space processors Leon3 and NOEL-V. We present the compiler support we have included in two compiler toolchains, gcc and llvm as well as a SIMD intrinsics library for easy programmability. Compiler modifications are kept to minimum in order to enable incremental qualification of the toolchains. We present our experience working with th

APA, Harvard, Vancouver, ISO, and other styles

30

Ren, Xiao Guang. "Optimize OpenFOAM from the Compiler Perspective." Applied Mechanics and Materials 687-691 (November 2014): 3183–86. http://dx.doi.org/10.4028/www.scientific.net/amm.687-691.3183.

Full text

Abstract:

OpenFOAM is a widely used open source computational fluid dynamics (CFD) , and the performance of its application is critical for the CFD user, and many researchers try to optimize it from various perspectives. In this paper, we try to optimization OpenFOAM application from the compiler perspective, which is the simplest way to get the optimization affect. We compare two mainstream compilers: Intel compiler icc and an open source compiler, as well as a serious of optimization option flags. Through the experiment, we find that Intel compiler has a much better performance than gcc, which is up t

APA, Harvard, Vancouver, ISO, and other styles

31

Xiao, Dongwei, Zhibo LIU, Yuanyuan Yuan, Qi Pang, and Shuai Wang. "Metamorphic Testing of Deep Learning Compilers." Proceedings of the ACM on Measurement and Analysis of Computing Systems 6, no. 1 (2022): 1–28. http://dx.doi.org/10.1145/3508035.

Full text

Abstract:

The prosperous trend of deploying deep neural network (DNN) models to diverse hardware platforms has boosted the development of deep learning (DL) compilers. DL compilers take the high-level DNN model specifications as input and generate optimized DNN executables for diverse hardware architectures like CPUs, GPUs, and various hardware accelerators. Compiling DNN models into high-efficiency executables is not easy: the compilation procedure often involves converting high-level model specifications into several different intermediate representations (IR), e.g., graph IR and operator IR, and perf

APA, Harvard, Vancouver, ISO, and other styles

32

HARDIN, THÉRÈSE, LUC MARANGET, and BRUNO PAGANO. "Functional runtime systems within the lambda-sigma calculus." Journal of Functional Programming 8, no. 2 (1998): 131–76. http://dx.doi.org/10.1017/s0956796898002986.

Full text

Abstract:

We define a weak λ-calculus, λσw, as a subsystem of the full λ-calculus with explicit substitutions λσ[uArr ]. We claim that λσw could be the archetypal output language of functional compilers, just as the λ-calculus is their universal input language. Furthermore, λσ[uArr ] could be the adequate theory to establish the correctness of functional compilers. Here we illustrate these claims by proving the correctness of four simplified compilers and runtime systems modelled as abstract machines. The four machines we prove are the Krivine machine, the SECD, the FAM and the CAM. Thus, we give the fi

APA, Harvard, Vancouver, ISO, and other styles

33

Gomard, Carsten K., and Neil D. Jones. "A partial evaluator for the untyped lambda-calculus." Journal of Functional Programming 1, no. 1 (1991): 21–69. http://dx.doi.org/10.1017/s0956796800000058.

Full text

Abstract:

AbstractThis article describes theoretical and practical aspects of an implemented self-applicable partial evaluator for the untyped lambda-calculus with constants and a fixed point operator. To the best of our knowledge, it is the first partial evaluator that is simultaneously higher-order, non-trivial, and self-applicable.Partial evaluation produces aresidual programfrom a source program and some of its input data. When given the remaining input data the residual program yields the same result that the source program would when given all its input data. Our partial evaluator produces a resid

APA, Harvard, Vancouver, ISO, and other styles

34

Dagienė, Valentina, and Rimgaudas Laucius. "Internationalization of Compilers." Informatica 18, no. 3 (2007): 363–74. http://dx.doi.org/10.15388/informatica.2007.182.

Full text

APA, Harvard, Vancouver, ISO, and other styles

35

Appleyard, John. "Comparing fortran compilers." ACM SIGPLAN Fortran Forum 20, no. 1 (2001): 6–10. http://dx.doi.org/10.1145/375738.375746.

Full text

APA, Harvard, Vancouver, ISO, and other styles

36

Henderson, Thomas C., and Ashok Samal. "Shape grammar compilers." Pattern Recognition 19, no. 4 (1986): 279–88. http://dx.doi.org/10.1016/0031-3203(86)90053-1.

Full text

APA, Harvard, Vancouver, ISO, and other styles

37

Chakraborty, Pinaki, Shweta Taneja, P. C. Saxena, and C. P. Katti. "Teaching purpose compilers." ACM Inroads 2, no. 2 (2011): 47–51. http://dx.doi.org/10.1145/1963533.1963549.

Full text

APA, Harvard, Vancouver, ISO, and other styles

38

McQuillen, Colleen, and Frederick H. White. "From the Compilers." Novoe literaturnoe obozrenie, no. 1 (2023): 11–14. http://dx.doi.org/10.53953/08696365_2023_179_1_11.

Full text

APA, Harvard, Vancouver, ISO, and other styles

39

Zemskova, Elena, and Elena Ostrovskaya. "From the Compilers." Novoe literaturnoe obozrenie, no. 4 (2022): 119–23. http://dx.doi.org/10.53953/08696365_2022_176_4_119.

Full text

APA, Harvard, Vancouver, ISO, and other styles

40

Butuzova, Ksenia, and Elena Glukhovskaya. "From the Compilers." Novoe literaturnoe obozrenie, no. 2 (2023): 88–90. http://dx.doi.org/10.53953/08696365_2023_180_2_88.

Full text

APA, Harvard, Vancouver, ISO, and other styles

41

Bondorf, Anders, and Jens Palsberg. "Generating action compilers by partial evaluation." Journal of Functional Programming 6, no. 2 (1996): 269–98. http://dx.doi.org/10.1017/s0956796800001684.

Full text

Abstract:

AbstractCompiler generation based on Mosses' action semantics has been studied by Brown, Moura, and Watt, and also by the second author. The core of each of their systems is a handwritten action compiler, producing either C or machine code. We have obtained an action compiler in a much simpler way: by partial evaluation of an action interpreter. Even though our compiler produces Scheme code, the code runs as fast as that produced by the previous action compilers.

APA, Harvard, Vancouver, ISO, and other styles

42

Liu, Jiawei, Yuxiang Wei, Sen Yang, Yinlin Deng, and Lingming Zhang. "Coverage-guided tensor compiler fuzzing with joint IR-pass mutation." Proceedings of the ACM on Programming Languages 6, OOPSLA1 (2022): 1–26. http://dx.doi.org/10.1145/3527317.

Full text

Abstract:

In the past decade, Deep Learning (DL) systems have been widely deployed in various application domains to facilitate our daily life, e.g., natural language processing, healthcare, activity recognition, and autonomous driving. Meanwhile, it is extremely challenging to ensure the correctness of DL systems (e.g., due to their intrinsic nondeterminism), and bugs in DL systems can cause serious consequences and may even threaten human lives. In the literature, researchers have explored various techniques to test, analyze, and verify DL models, since their quality directly affects the corresponding

APA, Harvard, Vancouver, ISO, and other styles

43

Traver, V. Javier. "On Compiler Error Messages: What TheySayand What TheyMean." Advances in Human-Computer Interaction 2010 (2010): 1–26. http://dx.doi.org/10.1155/2010/602570.

Full text

Abstract:

Programmers often encounter cryptic compiler error messages that are difficult to understand and thus difficult to resolve. Unfortunately, most related disciplines, including compiler technology, have not paid much attention to this important aspect that affects programmers significantly, apparently because it is felt that programmers should adapt to compilers. In this article, however, this problem is studied from the perspective of the discipline of human-computer interaction to gain insight into why compiler errors messages make the work of programmers more difficult, and how this situation

APA, Harvard, Vancouver, ISO, and other styles

44

Tassarotti, Joseph, and Jean-Baptiste Tristan. "Verified Density Compilation for a Probabilistic Programming Language." Proceedings of the ACM on Programming Languages 7, PLDI (2023): 615–37. http://dx.doi.org/10.1145/3591245.

Full text

Abstract:

This paper presents ProbCompCert, a compiler for a subset of the Stan probabilistic programming language (PPL), in which several key compiler passes have been formally verified using the Coq proof assistant. Because of the probabilistic nature of PPLs, bugs in their compilers can be difficult to detect and fix, making verification an interesting possibility. However, proving correctness of PPL compilation requires new techniques because certain transformations performed by compilers for PPLs are quite different from other kinds of languages. This paper describes techniques for verifying such t

APA, Harvard, Vancouver, ISO, and other styles

45

Chitra, A., and G. Sudha Sadasivam. "DESIGN AND IMPLEMENTATION OF A COMPONENTISED IDL COMPILER." Journal of Integrated Design and Process Science: Transactions of the SDPS, Official Journal of the Society for Design and Process Science 6, no. 3 (2002): 75–91. http://dx.doi.org/10.3233/jid-2002-6305.

Full text

Abstract:

An interface definition language (IDL) is a traditional language describing the interfaces between the components. IDL compilers generate stubs that provide communicating processes with the abstraction of local object invocation or procedure call. Typical IDL compilers are limited to a single IDL and target language, but the proposed IDL compiler is based on the insight that IDLs are true languages amenable to modern compilation techniques. Through the support of intermediate language representation called as Abstract Object Interface (AOI), our compiler can support multiple IDLs and target la

APA, Harvard, Vancouver, ISO, and other styles

46

Wang, Jiyuan, Yuxin Qiu, Ben Limpanukorn, Hong Jin Kang, Qian Zhang, and Miryung Kim. "DuoReduce: Bug Isolation for Multi-layer Extensible Compilation." Proceedings of the ACM on Software Engineering 2, FSE (2025): 647–67. https://doi.org/10.1145/3715747.

Full text

Abstract:

In recent years, the MLIR framework has had explosive growth due to the need for extensible deep learning compilers for hardware accelerators. Such examples include Triton, CIRCT, and ONNX-MLIR. MLIR compilers introduce significant complexities in localizing bugs or inefficiencies because of their layered optimization and transformation process with compilation passes. While existing delta debugging techniques can be used to identify a minimum subset of IR code that reproduces a given bug symptom, their naive application to MLIR is time-consuming because real-world MLIR compilers usually invol

APA, Harvard, Vancouver, ISO, and other styles

47

Xiao, Dongwei, Shuai Wang, Zhibo Liu, Yiteng Peng, Daoyuan Wu, and Zhendong Su. "Divergence-Aware Testing of Graphics Shader Compiler Back-Ends." Proceedings of the ACM on Programming Languages 9, PLDI (2025): 1367–91. https://doi.org/10.1145/3729305.

Full text

Abstract:

Graphics shaders are the core of modern 3D visual effects, enabling developers to create realistic, real-time rendering of 3D scenes. Shaders are specialized programs written in high-level shading languages like GLSL, and graphics shader compilers translate these high-level shader programs into low-level binaries that run on GPUs. These shader compilers are complex programs with multiple layers: front-end, middle-end, and back-end. Despite significant development efforts from industrial GPU vendors such as NVIDIA and AMD, graphics shader compilers still contain bugs that can impact downstream

APA, Harvard, Vancouver, ISO, and other styles

48

Arranz Olmos, Santiago, Gilles Barthe, Lionel Blatter, Benjamin Grégoire, and Vincent Laporte. "Preservation of Speculative Constant-Time by Compilation." Proceedings of the ACM on Programming Languages 9, POPL (2025): 1293–325. https://doi.org/10.1145/3704880.

Full text

Abstract:

Compilers often weaken or even discard software-based countermeasures commonly used to protect programs against side-channel attacks; worse, they may also introduce vulnerabilities that attackers can exploit. The solution to this problem is to develop compilers that preserve such countermeasures. Prior work establishes that (a mildly modified version of) the CompCert and Jasmin formally verified compilers preserve constant-time, an information flow policy that ensures that programs are protected against timing side-channel attacks. However, nothing is known about preservation of speculative co

APA, Harvard, Vancouver, ISO, and other styles

49

Baev, Roman Vyacheslavovich, Leonid Vladlenovich Skvortsov, Evgeny Alekseevich Kudryashov, Ruben Arturovich Buchatskiy, and Roman Aleksandrovich Zhuykov. "Prevention of vulnerabilities arising from optimization of code with Undefined Behavior." Proceedings of the Institute for System Programming of the RAS 33, no. 4 (2021): 195–210. http://dx.doi.org/10.15514/ispras-2021-33(4)-14.

Full text

Abstract:

Aggressive optimization in modern compilers may uncover vulnerabilities in program code that did not lead to bugs prior to optimization. The source of these vulnerabilities is in code with undefined behavior. Programmers use such constructs relying on some particular behavior these constructs showed before in their experience, but the compiler is not obliged to stick to that behavior and may change the behavior if it’s needed for optimization since the behavior is undefined by language standard. This article describes approaches to detection and elimination of vulnerabilities arising from opti

APA, Harvard, Vancouver, ISO, and other styles

50

Silva, Anderson Faustino da, and Vitor Costa. "The Design of the YAP Compiler: An Optimizing Compiler for Logic Programming Languages." JUCS - Journal of Universal Computer Science 12, no. (7) (2006): 764–87. https://doi.org/10.3217/jucs-012-07-0764.

Full text

Abstract:

Several techniques for implementing Prolog in a efficient manner have been devised since the original interpreter, many of them aimed at achieving more speed. There are two main approaches to efficient Prolog implementation: (1) compilers to bytecode and then interpreting it (emulators) or (2) compilers to native code. Emulators have smaller load/compilation time and are a good solution for their simplicity when speed is not a priority. Compilers are more complex than emulators, and the difference is much more acute if some form of code analysis is performed as part of the compilation, which i

APA, Harvard, Vancouver, ISO, and other styles

We offer discounts on all premium plans for authors whose works are included in thematic literature selections. Contact us to get a unique promo code!