Compiler Construction

This article presents XML-based tools for parser generation and data binding generation. The underlying concept is that of transformation between formal languages, which is a form of meta-programming. We discuss the benefits of such a declarative approach with well-defined semantics: productivity, maintainability, verifiability, performance and safety.

In Compiler Design courses, students learn how a program written in high level programming language and designed for humans understanding is systematically converted into low level assembly language understood by machines, through different representations. This article presents the design, educative characteristics and possibilities of a modular and didactic compiler for a Pascal-like programming minilanguage that is super-set of Niklaus Wirth's PL/0. The main feature is that it implements the compiling phases in such a way that the information delivered to each next one may be reflected as an XML document, which can be studied separately. It is also shown that its design is suitable for being included as learning tool into compiler design courses. It is possible to implement a compiler in a high-level language like Python.

Although optimization technology has been successful over the past 40 years, recent trends are emerging that demand we reconsider the paradigm that we are using for code optimization. In particular, the trends toward dynamic optimization, writing embedded system software in high level languages and the lack of significant performance improvement from current optimization research are forcing us to rethink what we know and do not know about optimization. A number of problems dealing with both semantic and application properties of optimizations have always existed but have been mostly ignored. The challenge in optimization today is to explore properties of optimizations and develop a framework for better understanding and use of optimizations. Fortunately, research is starting to explore properties, including proving the soundness of optimizations, proving the correctness of optimizations, specifications of optimizations, and the predictability of profits of optimizations. Not only must we understand the properties, but we also need to integrate the properties into a framework. Only then can we address the problems of the developing trends.

CPS transformation is an important tool in the compilation of functional programming languages. For strict languages, such as our web programming language "Rinso" or Microsoft's F#, monadic expressions can help with structuring and composing computations. To apply a CPS transformation in the compilation process of such a language, we integrate explicit monadic abstraction in a call-by-value source language, present a Danvy-Filinski-style CPS transformation for this extension, and verify that the translation preserves simple typing. We establish the simulation properties of this transformation in an untyped setting and relate it to a two stage transformation that implements the monadic abstraction with thunks and introduces continuations in a second step. Furthermore, we give a direct style translation which corresponds to the monadic translation.

Compiler compilers are in widespread use, but decompiler compilers are a more novel concept. This paper presents an approach for the decompilation of object code back to source code using a decompiler generator. An example decompilation is presented. Potential applications include reverse engineering, quality assessment, debugging and safety-critical code validation or verification.

Compiler writing is challenging. There are different kinds of parsers available for compiler designers and programmers to choose from during compiler development but very few are effective, efficient and convenient to be implemented. On the other hand, despite the growing number of parsers/parsing methods available for the construction of compilers some good quality parsers like the LR Parser has proven to be very flexible and efficient in developing parsing algorithms for virtually all programming languages. This is so because it possesses the top qualities of a good parser. For instance, LR Parsers does not give room for backtracking and it detects syntax errors as soon as they occur. This report extensively explains the concepts and the components of LR Parser. It does this by clearly defining all the terminologies associated with the LR Parser. It also outlines the reason why an LR Parser is preferred over the variety of other Parsers. This report explains the working/architecture (which includes the diagrams and the algorithm for LR Parsing) of an LR Parser and shows (step by step) how an LR Parsing table can be constructed. Finally, it compares and contrasts the difference and similarities of the LR Parser with its counterpart (the LL Parser). This report is useful for research work in syntax analysis phase of a compiler, parsers/parsing algorithms and more specifically LR Parser and generation of LR Parsing algorithms.

Pseudocode is an artificial and informal language that helps developers to create algorithms. In this paper a software tool is described, for translating the pseudocode into a particular source programming language. This tool compiles the pseudocode given by the user and translates it to a source programming language. The scope of the tool is very much wide as we can extend it to a universal programming tool which produces any of the specified programming language from a given pseudocode. Here we present the solution for translating the pseudocode to a programming language by using the different stages of a compiler.

Defining algorithms in a way which allows parallel execution is becoming increasingly important as multicore computers become ubiquitous. We present IFDS-A, a parallel algorithm for solving context-sensitive interprocedural finite distributive subset (IFDS) dataflow problems. IFDS-A defines these problems in terms of Actors, and dataflow dependencies as messages passed between these Actors. We implement the algorithm in Scala, and evaluate its performance against a comparable sequential algorithm. With eight cores, IFDS-A is 6.12 times as fast as with one core, and 3.35 times as fast as a baseline sequential algorithm. We also found that Scala’s default Actors implementation is not optimal for this algorithm, and that a custom-built implementation outperforms it by a significant margin. We conclude that Actors are an effective way to parallelize this type of algorithm.

Graphics Processing Units (GPUs) offer tremendous computational power. CUDA (Compute Unified Device Architecture) provides a multi-threaded parallel programming model, facilitating high performance implementations of general-purpose computations. However, the explicitly managed memory hierarchy and multi-level parallel view make manual development of high-performance CUDA code rather complicated. Hence the automatic transformation of sequential input programs into efficient parallel CUDA programs is of considerable interest.

Domain Specific Language (DSL) has been in the use from a long time. However, DSLs came to the limelight only in the recent past, around the time Java gained importance. The reason for this sudden upsurge in DSLs, the advantages it has to offer, the inherent complexities involved in the development of the language are discussed in the paper. Although a number of tools exist, this paper briefs on the use of ANTLR, for the development of a DSL.

Compiler construction is a widely used software engineering exercise, but because most students will not be compiler writers, care must be taken to make it relevant in a core curriculum. Auxiliary tools, such as generators and interpreters, often hinder the learning: students have to fight tool idiosyncrasies, mysterious errors, and other poorly educative issues. We introduce a set of tools especially designed or improved for compiler construction educative projects in C ++ . We also provide suggestions about new approaches to compiler construction. We draw guidelines from our experience to make tools suitable for education purposes.

Improving architectural energy efficiency is important to address diminishing energy efficiency gains from technology scaling. At the same time, limiting hardware complexity is also important. This paper presents a new processor architecture, the idempotent processor architecture, that advances both of these directions by presenting a new execution paradigm that allows speculative execution without the need for hardware checkpoints to recover from misspeculation, instead using only re-execution to recover. Idempotent processors execute programs as a sequence of compilerconstructed idempotent (re-executable) regions. The nature of these regions allows precise state to be reproduced by re-execution, obviating the need for hardware recovery support. We build upon the insight that programs naturally decompose into a series of idempotent regions and that these regions can be large. The paradigm of executing idempotent regions, which we call idempotent processing, can be used to support various types of speculation, including branch prediction, dependence prediction, or execution in the presence of hardware faults or exceptions.

A course in compiler construction seeks to develop an understanding of well-defined fundamental theory and typically involves the production of a language processor. In a graduate degree in software engineering, the development of a compiler contributes significantly to the developer's comprehension of the practical application of theoretical concepts.

Over the years we have seen and experienced an unprecedented evolution in the way programmers interact and pass instruction to the machine. Before now what was obtainable was an often tedious and painstaking process in which the programmer intending to perform a certain task or series of tasks had to pass instructions to the machine in a low level language which it directly understands in order for it to be able perform such a task, thus there became a growing need for abstraction to reduce the apparent complexity involved in interaction. Hence, the rise of various varieties of high level languages whose pseudo codes are written in English like form (mnemonics) which is then converted by a translator (which could either be an Assembler, compiler, interpreter or in some cases a combination of both) into its machine code equivalent.

With the growing demand of electronic devices, efficient conservation of energy has become the major concern. Investments are on the datacentres that consume huge amount of energy at both hardware and software levels as well as maintaining them. In a computing system, design, development and compilation has significant impact on conservation of energy. While it is difficult to control the impact of conservation of energy at hardware level, Green computation and in turn, Green Compilers are safest bet in controlling conservation of energy at software level. Controlled use of resources is achieved by the optimization of compiler and scheduling approach. The focus of this paper is to identify the tools and methods to achieve efficient use of resources and energy consumption and their utilization at compiler level. Distributed Green Compiler is a hardware independent green compiler which distributes source code over the network. Such compilers use green compiling techniques to conserve energy at software levels at compile time by transforming and reshaping binary codes by the application of green strategies. Resources are used efficiently in a manner that consumption of power is minimized and the emission of carbon dioxide is reduced at significant amount. The proposed compiler conserves energy clock cycles for a good range of nearly 40% by applying several green strategies. Keywords — Distributed Green Compiler (DGC), Energy Aware Compiler (EAC), DIET scheduler, Energy conservation GNU Compiler Collection (GCC).

In traditional compiler construction courses, each compiler phase is studied in detail before moving on to the next one. This not only places a great distance between theory and practice but also makes the students lose the big picture of the subject. We have been employing a different course format in which the subject is incrementally introduced through ten compilers of increasingly complexity. The first compiler is in fact just a syntax analyzer of a very simple language. The last one is a complete compiler of a Pascal-like language. Students of this course learn how to build compilers faster than the usual.

Top-down (LL) context-sensitive parsers with integrated synthesis and use of attributes are easy to expressin functional programming languages, but the elegant functional programming model can also serve as an exact prototype for a more efficient implementation of the technology in ANSI C. The result is a compiler-compiler that takes unlimited lookahead and backtracking, the extended BNF notation, and parameterized grammars with (higher-order) meta-parameters to the world of C programming. This article reports on the utility in question three years after public release. Precc generates standard ANSI C and is ‘plug compatible’ with lex-generated lexical analyzers prepared for the UNIX yacc compiler-compiler. In contrast to yacc, however, the generated code is modular, which allows parts of scripts to be compiled separately and linked together incrementally. The constructed code is relatively efficient, as is demonstrated by the example Occam parser treated in depth here, but the main advantages we claim are ease of use, separation of specification and implementation concerns, and maintainability.

Keywords: compiler-compiler; parsers; yacc; infinite-lookahead; top-down parsing; grammars; Occam

We present a Generalized LR parsing algorithm for unrestricted context-free grammars working in complexity O(n 3 ). It differs from previous approaches in the use of dynamic programming techniques to cope with the non determinism, instead of a graph-structured stack. The steps for deriving our algorithm from classical Earley's parsing algorithm are shown.

In recent years, functional programming languages have been cross-pollinating the object-oriented world. C# is now including constructs and concepts that are typical of functional languages, such as first-order functions and lazy evaluation, and there is a rising interest in multi-paradigm languages, like Python and Scala. The tendency to contamination between different programming styles can be read as the symptom of a need for more flexibility and conciseness in general-purpose languages. This is especially true when the constructs that a programming language provides are felt like insufficient or inadequate to express the solution of a domain-specific problem. In fact, we expect a domain-specific problem to be better modeled using a language that is specific to that domain. The Neverlang framework is designed to assist developers in the implementation of their own problem-oriented languages, using a sectional approach that favors code reuse. Neverlang acts as a toolchain that puts in sequence the typical stages of language development (defining the grammar, the semantics, and compiling the result), and generates code to implement an interpreter or a compiler. Unfortunately, generated code cannot be updated progressively: it has to be regenerated each time the sources change. We developed an LALR(1) parser generator that can update the implementation of an existing parser on the fly, avoiding any code generation intermediate step. We called it DEXTER: the Dynamically EXTEnsible Recognizer. In this paper we present the integration of Neverlang with DEXTER.

ProCoS aims to improve dependability, reduce timescales and cut development costs of construction for embedded systems, particularly in real-time and safety-critical applications. It uses and develops the results of basic research into fundamental properties of interactive systems. It aims to provide a scientific basis for future standards of practice in the development of embedded systems, ensuring correctness of all stages in the development, from elicitation and analysis of requirements through design and implementation of programs down
to compilation and execution on verified hardware.

Compiler compilers are in widespread use, but decompiler compilers are a more novel concept. This paper presents an approach for the decompilation of object code back to source code using a decompiler generator. An example decompilation is presented. Potential applications include reverse engineering, quality assessment, debugging and safety-critical code validation or verification.

Presentamos un compilador capaz de generar analizadores sintácticos a partir de esquemas de análisis sintáctico. Dichos esquemas son representaciones de los analizadores en forma de sistemas deductivos, que abstraen los detalles de implementación y permiten definir y comparar fácilmente diferentes algoritmos. Nuestro compilador es capaz de generar, a partir de uno de estos esquemas, el código de una implementación del algoritmo correspondiente, incluyendo el código necesario para gestionar la indexación de resultados intermedios para que dicha implementación sea eficiente. El sistema acepta todo tipo de esquemas de analizadores para gramáticas independientes del contexto, y se puede generalizar fácilmente a otros tipos de formalismos gramaticales.

Most points-to analysis research has been done on different systems by different groups, making it difficult to compare results, and to understand interactions between individual factors each group studied. Furthermore, points-to analysis for Java has been studied much less thoroughly than for C, and the tradeoffs appear very different. We introduce SPARK, a flexible framework for experimenting with points-to analyses for Java. SPARK supports equality-and subset-based analyses, variations in field sensitivity, respect for declared types, variations in call graph construction, off-line simplification, and several solving algorithms. SPARK is composed of building blocks on which new analyses can be based. We demonstrate SPARK in a substantial study of factors affecting precision and efficiency of subset-based points-to analyses, including interactions between these factors. Our results show that SPARK is not only flexible and modular, but also offers superior time/space performance when compared to other points-to analysis implementations.

Presentamos un compilador capaz de generar analizadores sintácticos a partir de esquemas de análisis sintáctico. Dichos esquemas son representaciones de los analizadores en forma de sistemas deductivos, que abstraen los detalles de implementación y permiten definir y comparar fácilmente diferentes algoritmos. Nuestro compilador es capaz de generar, a partir de uno de estos esquemas, el código de una implementación del algoritmo correspondiente, incluyendo el código necesario para gestionar la indexación de resultados intermedios para que dicha implementación sea eficiente. El sistema acepta todo tipo de esquemas de analizadores para gramáticas independientes del contexto, y se puede generalizar fácilmente a otros tipos de formalismos gramaticales.

Despite a long tradition of user centred human computer interaction design, movement interaction, as it is still in its early phase, could be described as technology driven. This paper suggests taking the starting point in personal experiences as well as theories, of modern dance and bodycentred philosophies, when studying human movement in order to inform people centred movement interaction design. Taking this approach also implies designing for a kinaesthetic interaction experience that includes the aesthetic part of kinaesthetics.

In this paper we de ne a new compilative version of constructive negation (intensional negation) in CLP and we prove its (nonground) correctness and completeness wrt the 3-valued completion. We show that intensional negation is essentially equivalent to constructive negation and that it is indeed more e cient, as one would expect from the fact that it is a compilative technique, with the transformation and the associated normalization process being performed once and for all on the source program. We de ne several formal non-ground semantics, based either on the derivation rule or on the least xpoint of an immediate consequence operator. All these semantics are proved to correctly model the observable behavior, from the viewpoint of answer constraints. We give some equivalence theorems and we show that all our denotations are the non-ground representation of a single partial interpretation, which is P " !, where P is the Fitting's operator 12].

Intel Extended Memory 64 Technology (EM64T) and AMD 64-bit architecture (AMD64) are emerging 64-bit x86 architectures that are fully x86 compatible. Compared with the 32-bit x86 architecture, the 64-bit x86 architectures cater some new features to applications. For instance, applications can address 64 bits of virtual memory space, perform operations on 64-bit-wide operands, get access to 16 general-purpose registers (GPRs) and 16 extended multi-media (XMM) registers, and use a register-based argument passing convention. In this paper, we investigate the performance impacts of these new features from compiler optimizations' standpoint. Our research compiler is based on the Intel Fortran/C++ production compiler, and our experiments are conducted on the SPEC2000 benchmark suite. Results show that for 64-bit-wide pointer and long data types, several SPEC2000 C benchmarks are slowed down by more than 20%, which is mainly due to the enlarged memory footprint. To evaluate the performance potential of 64-bit x86 architectures, we designed and implemented the LP32 code model such that the sizes of pointer and long are 32 bits. Our experiments demonstrate that on average the LP32 code model speeds up the SPEC2000 C benchmarks by 13.4%. For the register-based argument passing convention, our experiments show that the performance gain is less than 1% because of the aggressive function inlining optimization. Finally, we observe that using 16 GPRs and 16 XMM registers significantly outperforms the scenario when only 8 GPRs and 8 XMM registers are used. However, our results also show that using 12 GPRs and 12 XMM registers can achieve as competitive performance as employing 16 GPRs and 16 XMM registers.

During language evolution, compiler construction is usually performed along two dimensions: defining new abstract syntax tree (AST) classes, or adding new operations. In order to facilitate such changes, two software design patterns (i.e., the inheritance pattern and the visitor pattern) are widely used to help modularize the language constructs. However, as each design pattern is only suitable for one dimension of extension, neither of these two patterns can independently fulfill the evolution needs during the compiler construction process. In this paper, we analyze two dimensions of concerns in compiler construction and develop a paradigm allowing compiler evolution across these two dimensions using both object-orientation and aspect-orientation. Moreover, this approach provides an ability to perform pattern transformation based on pluggable aspects. A simple implementation of an expression language and its possible extension is demonstrated using Java and AspectJ.

The XANTLR/TDOM project is an implementation of a "typed" XML[1] Document Object Model initially used to represent abstract syntax trees in a compiler project. Tree classes, SAX event receivers, visitor classes and DTD are automatically derived from a sparsely annotated ANTLR grammar. Mapping tag values onto the type system of the target language allows for the compilation of syntax, mostly yielding large increases in computational performance. Automized generation significantly decreases programming efforts and increases maintainability. The currently supported target language is JAVA.

Attribute grammars have been used extensively in every phase of traditional compiler construction. Since some of these phases have also been used in automated hardware synthesis (hardware compilation), attribute grammars can be effectively adopted to handle the two major tasks of high-level hardware synthesis, operation scheduling and hardware allocation, implementing various algorithms. This paper presents an attribute grammar driven scheduling

ProCoS aims to improve dependability, reduce timescales and cut development costs of construction for embedded systems, particularly in real-time and safety-critical applications. It uses and develops the results of basic research into fundamental properties of interactive systems. It aims to provide a scientific basis for future standards of practice in the development of embedded systems, ensuring correctness of all stages in the development, from elicitation and analysis of requirements through design and implementation of ...

The productivity of a compiler development team depends on its ability not only to the design effective solutions to known code generation problems, but also to uncover potential code improvement opportunities. This paper describes a data mining tool that can be used to identify such opportunities based on a combination of hardware-profiling data and on compiler-generated counters. This data is combined into an Execution Flow Graph (EFG) and then FlowGSP, a new data mining algorithm, finds sequences of attributes associated with subpaths of the EFG. Many examples of important opportunities for code improvement in the IBM R Testarossa compiler are described to illustrate the usefulness of this data mining technique. This mining tool is specially useful for programs whose execution is not dominated by a small set of frequently executed loops. Information about the amount of space and time required to run the mining tool are also provided. In comparison with manual search through the data, the mining tool saved a significant amount of compiler development time and effort.

We here present new insights of properties of real-life interference graphs emerging in register allocation. These new insights imply good hopes for a possibility of improving the coloring approach towards optimal solutions. The conclusions are based on measurements of nearly 28,000 real instances of such interference graphs. All the instances explored are determined to possess the so-called 1-perfectness property, a fact that seems to make them easy to color optimally. The exact algorithms presented not only produce better solutions than the traditional heuristic methods, but also, indeed, seem to perform surprisingly fast, according to the measurements on our implementations.