Log in

Relevant bibliographies by topics / Language compilers / Journal articles

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

Journal articles on the topic 'Language compilers'

Author: Grafiati

Published: 10 December 2022

Last updated: 31 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 'Language 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

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

2

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

3

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

4

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

5

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

6

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

7

Mironov, Sergei Vladimirovich, Inna Aleksandrovna Batraeva, and Pavel Dmitrievich Dunaev. "Library for Development of Compilers." Proceedings of the Institute for System Programming of the RAS 34, no. 5 (2022): 77–88. http://dx.doi.org/10.15514/ispras-2022-34(5)-5.

Full text

Abstract:

This work is devoted to the development of a library designed to implement compilers. The article contains a description of the library's features and the main points of its functioning. In the course of the work, the generation of parsers using LR(1)-automata was studied and implemented, two auxiliary languages were designed and implemented: a semantic network query language and a language designed to generate executable code. The result of the work is a library for the platform .NET (the library was tested for the C# language), which contains classes that make easier the implementation of so

APA, Harvard, Vancouver, ISO, and other styles

8

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

9

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

10

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

11

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

12

Pompougnac, Hugo, Ulysse Beaugnon, Albert Cohen, and Dumitru Potop Butucaru. "Weaving Synchronous Reactions into the Fabric of SSA-form Compilers." ACM Transactions on Architecture and Code Optimization 19, no. 2 (2022): 1–25. http://dx.doi.org/10.1145/3506706.

Full text

Abstract:

We investigate the programming of reactive systems combining closed-loop control with performance-intensive components such as Machine Learning (ML). Reactive control systems are often safety-critical and associated with real-time execution requirements, a domain of predilection for synchronous programming languages. Extending the high levels of assurance found in reactive control systems to computationally intensive code remains an open issue. We tackle it by unifying concepts and algorithms from synchronous languages with abstractions commonly found in general-purpose and ML compilers. This

APA, Harvard, Vancouver, ISO, and other styles

13

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

14

Dold, Axel, Friedrich von Henke, and Wolfgang Goerigk. "A Completely Verified Realistic Bootstrap Compiler." International Journal of Foundations of Computer Science 14, no. 04 (2003): 659–80. http://dx.doi.org/10.1142/s0129054103001947.

Full text

Abstract:

This paper reports on a large verification effort in constructing an initial fully trusted bootstrap compiler executable for a realistic system programming language and real target processor. The construction and verification process comprises three tasks: the verification of the compiling specification (a relation between abstract source and target programs) with respect to the language semantics and a realistic correctness criterion. This proof has been completely mechanized using the PVS verification system and is one of the largest case-studies in formal verification we are aware of. Secon

APA, Harvard, Vancouver, ISO, and other styles

15

Michael, Alexandra E., Anitha Gollamudi, Jay Bosamiya, et al. "MSWasm: Soundly Enforcing Memory-Safe Execution of Unsafe Code." Proceedings of the ACM on Programming Languages 7, POPL (2023): 425–54. http://dx.doi.org/10.1145/3571208.

Full text

Abstract:

Most programs compiled to WebAssembly (Wasm) today are written in unsafe languages like C and C++. Unfortunately, memory-unsafe C code remains unsafe when compiled to Wasm—and attackers can exploit buffer overflows and use-after-frees in Wasm almost as easily as they can on native platforms. Memory- Safe WebAssembly (MSWasm) proposes to extend Wasm with language-level memory-safety abstractions to precisely address this problem. In this paper, we build on the original MSWasm position paper to realize this vision. We give a precise and formal semantics of MSWasm, and prove that well-typed MSWas

APA, Harvard, Vancouver, ISO, and other styles

16

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

17

Mehta, Meetesh Kalpesh, Sebastián Krynski, Hugo Musso Gualandi, Manas Thakur, and Jan Vitek. "Reusing Just-in-Time Compiled Code." Proceedings of the ACM on Programming Languages 7, OOPSLA2 (2023): 1176–97. http://dx.doi.org/10.1145/3622839.

Full text

Abstract:

Most code is executed more than once. If not entire programs then libraries remain unchanged from one run to the next. Just-in-time compilers expend considerable effort gathering insights about code they compiled many times, and often end up generating the same binary over and over again. We explore how to reuse compiled code across runs of different programs to reduce warm-up costs of dynamic languages. We propose to use speculative contextual dispatch to select versions of functions from an off-line curated code repository . That repository is a persistent database of previously compiled fun

APA, Harvard, Vancouver, ISO, and other styles

18

Stepanov, D. S., and V. M. Itsykson. "Finding Compiler Bugs Duplicates by Generating Witness Programs." Programmnaya Ingeneria 14, no. 4 (2023): 165–74. http://dx.doi.org/10.17587/prin.14.165-174.

Full text

Abstract:

Programming language compilers are complex software projects, the quality of which directly affects the quality of programs created by them. Therefore, compilers are subject to increased requirements for such software quality characteristics as functional suitability, reliability, performance level, safety, etc. To ensure quality, various methods are used: user and manual testing, tools for automatic error detection. And due to many methods of searching for bugs often situations arise when the same error, especially if its cause is trivial, is detected repeatedly, and the test cases that lead

APA, Harvard, Vancouver, ISO, and other styles

19

Clément, Basile, and Albert Cohen. "End-to-end translation validation for the halide language." Proceedings of the ACM on Programming Languages 6, OOPSLA1 (2022): 1–30. http://dx.doi.org/10.1145/3527328.

Full text

Abstract:

This paper considers the correctness of domain-specific compilers for tensor programming languages through the study of Halide, a popular representative. It describes a translation validation algorithm for affine Halide specifications, independently of the scheduling language. The algorithm relies on “prophetic” annotations added by the compiler to the generated array assignments. The annotations provide a refinement mapping from assignments in the generated code to the tensor definitions from the specification. Our implementation leverages an affine solver and a general SMT solver, and scales

APA, Harvard, Vancouver, ISO, and other styles

20

Kim, Caleb, Pai Li, Anshuman Mohan, Andrew Butt, Adrian Sampson, and Rachit Nigam. "Unifying Static and Dynamic Intermediate Languages for Accelerator Generators." Proceedings of the ACM on Programming Languages 8, OOPSLA2 (2024): 2242–67. http://dx.doi.org/10.1145/3689790.

Full text

Abstract:

Compilers for accelerator design languages (ADLs) translate high-level languages into application-specific hardware. ADL compilers rely on a hardware control interface to compose hardware units. There are two choices: static control, which relies on cycle-level timing; or dynamic control, which uses explicit signalling to avoid depending on timing details. Static control is efficient but brittle; dynamic control incurs hardware costs to support compositional reasoning. Piezo is an ADL compiler that unifies static and dynamic control in a single intermediate language (IL). Its key insight is th

APA, Harvard, Vancouver, ISO, and other styles

21

Fallin, Chris, and Maxwell Bernstein. "Partial Evaluation, Whole-Program Compilation." Proceedings of the ACM on Programming Languages 9, PLDI (2025): 324–47. https://doi.org/10.1145/3729259.

Full text

Abstract:

There is a tension in dynamic language runtime design between speed and correctness. State-of-the-art JIT compilation, the result of enormous industrial investment and significant research, achieves heroic speedups at the cost of complexity. This complexity leads to subtle and sometimes catastrophic correctness bugs. Much of this complexity comes from the existence of multiple tiers and the need to maintain correspondence between these separate definitions of the language’s semantics; it also comes from the indirect nature of the semantics implicitly encoded in a compiler backend. One way to a

APA, Harvard, Vancouver, ISO, and other styles

22

Huang, Yulong, and Jeremy Yallop. "Defunctionalization with Dependent Types." Proceedings of the ACM on Programming Languages 7, PLDI (2023): 516–38. http://dx.doi.org/10.1145/3591241.

Full text

Abstract:

The defunctionalization translation that eliminates higher-order functions from programs forms a key part of many compilers. However, defunctionalization for dependently-typed languages has not been formally studied. We present the first formally-specified defunctionalization translation for a dependently-typed language and establish key metatheoretical properties such as soundness and type preservation. The translation is suitable for incorporation into type-preserving compilers for dependently-typed languages

APA, Harvard, Vancouver, ISO, and other styles

23

Deeds, Kyle, Willow Ahrens, Magdalena Balazinska, and Dan Suciu. "Galley: Modern Query Optimization for Sparse Tensor Programs." Proceedings of the ACM on Management of Data 3, no. 3 (2025): 1–24. https://doi.org/10.1145/3725301.

Full text

Abstract:

The tensor programming abstraction is a foundational paradigm which allows users to write high performance programs via a high-level imperative interface. Recent work on sparse tensor compilers has extended this paradigm to sparse tensors (i.e., tensors where most entries are not explicitly represented). With these systems, users define the semantics of the program and the algorithmic decisions in a concise language that can be compiled to efficient low-level code. However, these systems still require users to make complex decisions about program structure and memory layouts to write efficient

APA, Harvard, Vancouver, ISO, and other styles

24

BERNARD, THOMAS A. M., CLEMENS GRELCK, and CHRIS R. JESSHOPE. "ON THE COMPILATION OF A LANGUAGE FOR GENERAL CONCURRENT TARGET ARCHITECTURES." Parallel Processing Letters 20, no. 01 (2010): 51–69. http://dx.doi.org/10.1142/s0129626410000053.

Full text

Abstract:

The challenge of programming many-core architectures efficiently and effectively requires models and methods to co-design chip architectures and their software tool chain, using an approach that is both vertical and general. In this paper, we present compilation schemes for a general model of concurrency captured in a parallel language designed for system-level programming and as a target for higher level compilers. We also expose the challenges of integrating these transformation rules into a sequential-oriented compiler. Moreover, we discuss resource mapping inherent to those challenges. Our

APA, Harvard, Vancouver, ISO, and other styles

25

Lecoeur, Bastien, Hasan Mohsin, and Alastair F. Donaldson. "Program Reconditioning: Avoiding Undefined Behaviour When Finding and Reducing Compiler Bugs." Proceedings of the ACM on Programming Languages 7, PLDI (2023): 1801–25. http://dx.doi.org/10.1145/3591294.

Full text

Abstract:

We introduce program reconditioning, a method for allowing program generation and differential testing to be used to find miscompilation bugs, and test-case reduction to be used to simplify bug-triggering programs, even when (a) the programming language of interest features undefined behaviour (UB) and (b) no tools exist to detect and avoid this UB. We present two program generation tools based on our reconditioning idea: GLSLsmith for the OpenGL Shading Language (GLSL), a widely-used language for graphics programming, and WGSLsmith for the WebGPU Shading Language (WGSL), a new language for we

APA, Harvard, Vancouver, ISO, and other styles

26

Spanier, Adam, and William Mahoney. "Static Vulnerability Analysis Using Intermediate Representations: A Literature Review." European Conference on Cyber Warfare and Security 22, no. 1 (2023): 458–65. http://dx.doi.org/10.34190/eccws.22.1.1154.

Full text

Abstract:

Analysis (SA) in Cybersecurity is a practice aimed at detecting vulnerabilities within the source code of a program. Modern SA applications, though highly sophisticated, lack programming language agnostic generalization, instead requiring codebase specific implementations for each programming language. The manner in which SA is implemented today, though functional, requires significant man hours to develop and maintain, higher costs due to custom applications for each language, and creates inconsistencies in implementation from SA-tool to SA-tool. A source of programming language generalizatio

APA, Harvard, Vancouver, ISO, and other styles

27

Hanfeng, Chen. "A SUCCINCT PROGRAMMING LANGUAGE WITH A NATIVE DATABASE COMPONENT." IJPLA 07, no. 01 (2017): 01–14. https://doi.org/10.5281/zenodo.1155312.

Full text

Abstract:

ELI is a succinct interactive programming language system organized around a few simple principles. Its main data structures include arrays, lists, dictionaries and tables. In addition, it has an integrated database management component which is capable of processing a basic set of SQL statements. ELI, with a compiler, covering the array portion of the language, is also an excellent tool for coding scientific and engineering solutions. Moreover, it is productive in writing complex applications as well, such as compilers and trading systems.

APA, Harvard, Vancouver, ISO, and other styles

28

Biggar, Paul, Edsko de Vries, and David Gregg. "A practical solution for achieving language compatibility in scripting language compilers." Science of Computer Programming 77, no. 9 (2012): 971–89. http://dx.doi.org/10.1016/j.scico.2011.01.004.

Full text

APA, Harvard, Vancouver, ISO, and other styles

29

Klepinin, A. V., and A. A. Melentyev. "Integration of semantic verifiers into Java language compilers." Automatic Control and Computer Sciences 45, no. 7 (2011): 408–12. http://dx.doi.org/10.3103/s014641161107008x.

Full text

APA, Harvard, Vancouver, ISO, and other styles

30

Ciric, Miroslav, and Svetozar Rancic. "Parsing in different languages." Facta universitatis - series: Electronics and Energetics 18, no. 2 (2005): 299–307. http://dx.doi.org/10.2298/fuee0502299c.

Full text

Abstract:

A compiler is a translator that accepts as input formatted source file or files, and produces as output a file that may be run directly on a computer. Given the same ANSI C++ compliant input file, two different ANSI C++ compliant compilers running on the same operating system produce two different executable programs that should execute in exactly the same way. To some degree, this is achieved by the standardization of the C++ language, but it is also possible because computer programming languages like C++ can be compiled using reliable technologies with long traditions and understood charact

APA, Harvard, Vancouver, ISO, and other styles

31

Gagan, B. R., Shivaprakash T, Thirumalai Shaktivel C, Vaishak P, and Kushal Kumar B. N. "Design of a New Language Seeks Literature Survey." International Journal for Research in Applied Science and Engineering Technology 10, no. 3 (2022): 1623–27. http://dx.doi.org/10.22214/ijraset.2022.40949.

Full text

Abstract:

Abstract: In a scientific study, computing is a must-have tool. In general, scientists have various difficulties, requirements, and views when it comes to computation, which need to be addressed by the programming language that they use, this cannot be satisfied by general-purpose languages. Also, researchers need to concentrate on the issue they are working on rather than the optimizations for the calculations, so instead of using a general-purpose language, if there exists a language whose compiler would take care of those optimizations, it would make their work easier and faster. This is a

APA, Harvard, Vancouver, ISO, and other styles

32

Mascarenhas, Fabio, and Roberto Ierusalimschy. "Running Lua Scripts on the CLR through Bytecode Translation." JUCS - Journal of Universal Computer Science 11, no. (7) (2005): 1275–90. https://doi.org/10.3217/jucs-011-07-1275.

Full text

Abstract:

The .NET Common Language Runtime (CLR) aims to provide interoperability among code written in several different languages, but porting scripting languages to it, so that scripts can run natively, has been hard. This paper presents our approach for running scripts written in Lua, a scripting language, on the .NET CLR. Previous approaches for running scripting languages on the CLR have focused on extending the CLR, statically generating CLR classes from user-defined types in the source languages. They required either language extensions or restrictions on the languages' dynamic features. Our app

APA, Harvard, Vancouver, ISO, and other styles

33

Klimis, Vasileios, Jack Clark, Alan Baker, David Neto, John Wickerson, and Alastair F. Donaldson. "Taking Back Control in an Intermediate Representation for GPU Computing." Proceedings of the ACM on Programming Languages 7, POPL (2023): 1740–69. http://dx.doi.org/10.1145/3571253.

Full text

Abstract:

We describe our experiences successfully applying lightweight formal methods to substantially improve and reformulate an important part of Standard Portable Intermediate Representation SPIRV, an industry-standard language for GPU computing. The formal model that we present has allowed us to (1) identify several ambiguities and needless complexities in the way that structured control flow was defined in the SPIRV specification; (2) interact with the authors of the SPIRV specification to rectify these problems; (3) validate the developer tools and conformance test suites that support the SPIRV l

APA, Harvard, Vancouver, ISO, and other styles

34

Siebert, Dr Fridtjof. "Fuzion - Safety through Simplicity." ACM SIGAda Ada Letters 41, no. 1 (2022): 83–86. http://dx.doi.org/10.1145/3570315.3570323.

Full text

Abstract:

Fuzion is a modern, general purpose programming language that unifies concepts found in structured, functional and object-oriented programming languages into the concept of a Fuzion feature. It combines a powerful syntax and safety features based on the design-by-contract principle with a simple intermediate representation that enables powerful optimizing compilers and static analysis tools to verify correctness aspects. Fuzion maps different concepts into the concept of a Fuzion feature and uses a simple intermediate language that is friendly for static analysis tools as well as for optimizin

APA, Harvard, Vancouver, ISO, and other styles

35

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

36

Fitzgibbons, Michael, Zoe Paraskevopoulou, Noble Mushtak, Michelle Thalakottur, Jose Sulaiman Manzur, and Amal Ahmed. "RichWasm: Bringing Safe, Fine-Grained, Shared-Memory Interoperability Down to WebAssembly." Proceedings of the ACM on Programming Languages 8, PLDI (2024): 1656–79. http://dx.doi.org/10.1145/3656444.

Full text

Abstract:

Safe, shared-memory interoperability between languages with different type systems and memory-safety guarantees is an intricate problem as crossing language boundaries may result in memory-safety violations. In this paper, we present RichWasm, a novel richly typed intermediate language designed to serve as a compilation target for typed high-level languages with different memory-safety guarantees. RichWasm is based on WebAssembly and enables safe shared-memory interoperability by incorporating a variety of type features that support fine-grained memory ownership and sharing. RichWasm is rich e

APA, Harvard, Vancouver, ISO, and other styles

37

WELLS, J. B., ALLYN DIMOCK, ROBERT MULLER, and FRANKLYN TURBAK. "A calculus with polymorphic and polyvariant flow types." Journal of Functional Programming 12, no. 3 (2002): 183–227. http://dx.doi.org/10.1017/s0956796801004245.

Full text

Abstract:

We present λCIL, a typed λ-calculus which serves as the foundation for a typed intermediate language for optimizing compilers for higher-order polymorphic programming languages. The key innovation of λCIL is a novel formulation of intersection and union types and flow labels on both terms and types. These flow types can encode polyvariant control and data flow information within a polymorphically typed program representation. Flow types can guide a compiler in generating customized data representations in a strongly typed setting. Since λCIL enjoys confluence, standardization, and subject redu

APA, Harvard, Vancouver, ISO, and other styles

38

Aho, Alfred, and Jeffrey Ullman. "Abstractions, their algorithms, and their compilers." Communications of the ACM 65, no. 2 (2022): 76–91. http://dx.doi.org/10.1145/3490685.

Full text

Abstract:

Jeffrey D. Ullman and Alfred V. Aho are recipients of the 2020 ACM A.M. Turing award. They were recognized for creating fundamental algorithms and theory underlying programming language implementation and for synthesizing these results and those of others in their highly influential books, which educated generations of computer scientists.

APA, Harvard, Vancouver, ISO, and other styles

39

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

40

Boujarwah, A. S., K. Saleh, and J. Al-Dallal. "Testing syntax and semantic coverage of Java language compilers." Information and Software Technology 41, no. 1 (1999): 15–28. http://dx.doi.org/10.1016/s0950-5849(98)00075-5.

Full text

APA, Harvard, Vancouver, ISO, and other styles

41

Prastowo, Tadeus, Luigi Palopoli, and Luca Abeni. "Tice: A real‐time language compilable using C++ compilers." Software: Practice and Experience 50, no. 12 (2020): 2252–92. http://dx.doi.org/10.1002/spe.2891.

Full text

APA, Harvard, Vancouver, ISO, and other styles

42

Bahr, Patrick, and Graham Hutton. "Monadic compiler calculation (functional pearl)." Proceedings of the ACM on Programming Languages 6, ICFP (2022): 80–108. http://dx.doi.org/10.1145/3547624.

Full text

Abstract:

Bahr and Hutton recently developed a new approach to calculating correct compilers directly from specifications of their correctness. However, the methodology only considers converging behaviour of the source language, which means that the compiler could potentially produce arbitrary, erroneous code for source programs that diverge. In this article, we show how the methodology can naturally be extended to support the calculation of compilers that address both convergent and divergent behaviour simultaneously , without the need for separate reasoning for each aspect. Our approach is based on th

APA, Harvard, Vancouver, ISO, and other styles

43

Shugaley, Nikita Yurievich, Vladislav Anatolevich Ivanishin, and Alexander Vladimirovich Monakov. "Detecting Potentially Clobbered Variables due to the Use of Nonlocal Jumps Functions." Proceedings of the Institute for System Programming of the RAS 35, no. 6 (2023): 121–34. http://dx.doi.org/10.15514/ispras-2023-35(6)-7.

Full text

Abstract:

The reason of undefined behavior is source code written in violation of the C language standard. Undefined behavior leads to vulnerabilities in software. One of the common sources of undefined behavior is an incorrect use of functions for nonlocal jumps (in particular setjmp and longjmp). This paper considers the means of detecting this type of undefined behavior which are implemented in the major modern compilers (GCC, Clang, MSVC). We conclude that these means either have significant disadvantages or are absent in some compilers. This paper presents the implementation of a new method of comp

APA, Harvard, Vancouver, ISO, and other styles

44

Элова, Дилрабо Кудратиллаевна. "WAYS TO DEFINE ARTIFICIAL LANGUAGES: SYNTAX AND SEMANTICS OF THE LANGUAGE." "Science and innovation" international scientific journal. ISSN: 2181-3337 1, no. 4 (2022): 527–32. https://doi.org/10.5281/zenodo.6975110.

Full text

Abstract:

<em>This article discusses the ways of defining artificial languages, indicates the syntax and semantics of the language. So, grammar is a description of a way of constructing sentences of a language. In other words, grammar is the mathematical system that defines language. Language syntax is a set of rules that define the allowed constructs of a language. Syntax defines the "form of the language" - defines the set of character strings that belong to the language. Since programming languages are not purely formal languages and carry some meaning (semantics), the problem of parsing fo

APA, Harvard, Vancouver, ISO, and other styles

45

Wang, Qian, and Ralf Jung. "Rustlantis: Randomized Differential Testing of the Rust Compiler." Proceedings of the ACM on Programming Languages 8, OOPSLA2 (2024): 1955–81. http://dx.doi.org/10.1145/3689780.

Full text

Abstract:

Compilers are at the core of all computer architecture. Their middle-end and back-end are full of subtle code that is easy to get wrong. At the same time, the consequences of compiler bugs can be severe. Therefore, it is important that we develop techniques to increase our confidence in compiler correctness, and to help find the bugs that inevitably happen. One promising such technique that has successfully found many compiler bugs in the past is randomized differential testing , a fuzzing approach whereby the same program is executed with different compilers or different compiler settings to

APA, Harvard, Vancouver, ISO, and other styles

46

Ishtiaq, Muhammad, Maryam Gulzar, and Muhammad Farhat Ullah. "RUPT: An Extension to Traditional Compilers in C++ to Support Programming in Native Language." UCP Journal of Engineering & Information Technology 3, no. 1 (2025): 41–48. https://doi.org/10.24312/ucp-jeit.03.01.591.

Full text

Abstract:

The medium of instruction has a significant impact on effective communication and comprehension. The majority of literature is available in English because it is a universal language; however, if someone is provided with the information in their native language, they will comprehend the concept much more effectively. In computer science, source code of programming languages is written in the English language, whereas endemic language has its own impact. To address this gap, this study has rendered a framework, “Roman Urdu Programming Translator” (RUPT), that will be used to translate a program

APA, Harvard, Vancouver, ISO, and other styles

47

Benzaken, Véronique, Évelyne Contejean, Mohammed Houssem Hachmaoui, et al. "Translating canonical SQL to imperative code in Coq." Proceedings of the ACM on Programming Languages 6, OOPSLA1 (2022): 1–27. http://dx.doi.org/10.1145/3527327.

Full text

Abstract:

SQL is by far the most widely used and implemented query language. Yet, on some key features, such as correlated queries and NULL value semantics, many implementations diverge or contain bugs. We leverage recent advances in the formalization of SQL and query compilers to develop DBCert, the first mechanically verified compiler from SQL queries written in a canonical form to imperative code. Building DBCert required several new contributions which are described in this paper. First, we specify and mechanize a complete translation from SQL to the Nested Relational Algebra which can be used for q

APA, Harvard, Vancouver, ISO, and other styles

48

Li, Shaohua, Theodoros Theodoridis, and Zhendong Su. "Boosting Compiler Testing by Injecting Real-World Code." Proceedings of the ACM on Programming Languages 8, PLDI (2024): 223–45. http://dx.doi.org/10.1145/3656386.

Full text

Abstract:

We introduce a novel approach for testing optimizing compilers with code from real-world applications. The main idea is to construct well-formed programs by fusing multiple code snippets from various real-world projects. The key insight is backed by the fact that the large volume of real-world code exercises rich syntactical and semantic language features, which current engineering-intensive approaches like random program generators are hard to fully support. To construct well-formed programs from real-world code, our approach works by (1) extracting real-world code at the granularity of funct

APA, Harvard, Vancouver, ISO, and other styles

49

Zhang, Ling, Yuting Wang, Jinhua Wu, Jérémie Koenig, and Zhong Shao. "Fully Composable and Adequate Verified Compilation with Direct Refinements between Open Modules." Proceedings of the ACM on Programming Languages 8, POPL (2024): 2160–90. http://dx.doi.org/10.1145/3632914.

Full text

Abstract:

Verified compilation of open modules (i.e., modules whose functionality depends on other modules) provides a foundation for end-to-end verification of modular programs ubiquitous in contemporary software. However, despite intensive investigation in this topic for decades,the proposed approaches are still difficult to use in practice as they rely on assumptions about the internal working of compilers which make it difficult for external users to apply the verification results. We propose an approach to verified compositional compilation without such assumptions in the setting of verifying compi

APA, Harvard, Vancouver, ISO, and other styles

50

Golumbic, Martin Charles, and Vladimir Rainish. "Instruction Scheduling Across Control Flow." Scientific Programming 2, no. 3 (1993): 1–5. http://dx.doi.org/10.1155/1993/536143.

Full text

Abstract:

Instruction scheduling algorithms are used in compilers to reduce run-time delays for the compiled code by the reordering or transformation of program statements, usually at the intermediate language or assembly code level. Considerable research has been carried out on scheduling code within the scope of basic blocks, i.e., straight line sections of code, and very effective basic block schedulers are now included in most modern compilers and especially for pipeline processors. In previous work Golumbic and Rainis: IBM J. Res. Dev., Vol. 34, pp.93–97, 1990, we presented code replication techniq

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!