Search

Summary: Today's embedded devices and sensor networks are becoming more and more sophisticated, requiring more efficient and highly flexible compilers. Engineers are discovering that many of the compilers in use today are ill-suited to meet the demands of more advanced computer architectures. Updated to include the latest techniques, The Compiler Design Handbook, Second Edition offers a unique opportunity for designers and researchers to update their knowledge, refine their skills, and prepare for emerging innovations. The completely revised handbook includes 14 new chapters addressing topics such as worst case execution time estimation, garbage collection, and energy aware compilation. The editors take special care to consider the growing proliferation of embedded devices, as well as the need for efficient techniques to debug faulty code. New contributors provide additional insight to chapters on register allocation, software pipelining, instruction scheduling, and type systems.

An imperative language such as C++ is a familiar object oriented programming that is widely used for reusability and increased ability to enlighten with other languages. The objective of software testing is to uncover as many errors as possible with a minimum cost. Testing is not confined only to the detection of bugs, it also assists with the evaluation of the functional properties of the software. A piece of software can be tested to increase the confidence by exposing potential flaws or deviations from the user's requirements. Unit testing is to authenticate incorrectness and succeed when an error is detected. This work addresses the detection of defects in C# applications, which leads to logical error. Logical errors occur when the code does not perform the way it is intended to perform. The detection and elimination of the logical bug is one of the aims of testing. These errors are very difficult to track since the compiler does not provide assistance. One of the reasons for Errors is the presence of unintended characters. A missing or an incorrect piece of code is a defect and it remains undetected until an event activates it. When the code performs unit test, automatically each and individual line of code attempts the syntax checking. It helps to detect and remove all logical and syntactical defects from a given piece of code; unit testing is the most essential technique which can be used for executing the code with checking process. To catch all kinds of defects in the coding phase, the unit tests take a place on C++ and C# applications. This work includes the defects occur due to unintended characters, wrong usage of data member and formal parameter and a missing argument indicator in console-based applications of C#. In addition to that, the interface anomaly and inheritance anomaly are also detected. Because of enrichment, the comparison has been made on the object oriented source code such as C++ with C# applications. By this approach instantly, unit testing improves the quality of the code in terms of reducing the programmer's burden, time and effort. [ABSTRACT FROM AUTHOR]

The technology of parameters recovery is very important for researchers in the area of designing of binary translation systems. It has much to do with architecture, compiler, operating system, and many other aspects. The recovery of floating-point parameters is more complex, compared with the recovery of parameters in other types. This paper presents a new approach to floating-point parameters recovery based on the concept of parameter slot. It makes the recovery of parameters easy and especially precise to implement. This method has been used in the design of a binary translation system ITA, which is designed for a 64-bit architecture Itanium. Through the test using the programs in SPEC2000, this method is proved to be sound and effective in the ITA translation system. [ABSTRACT FROM AUTHOR]

This paper describes XML externalization built into compiler front-ends and its application to quick reverse engineering tool development. A new parser generator MJay was developed to build XML externalization functionality into compiler front-ends. After replacing the original parser generator with MJay, generating a parser using it, and modifying a few lines of source code in the compiler, we were able to obtain a special compiler that externalizes three types of information in the form of XML data, namely, lexical information, syntactic information, and parse tree. The syntactic information was applied to develop a reverse engineering tool for C#. The tool shows a performance penalty from the viewpoint of the generated XML document size. However, even with a storage penalty, the quick development is a far superior option. [ABSTRACT FROM AUTHOR]

The Mobile Resource Guarantees (MRG) project has developed a proof-carrying-code infrastructure for certifying resource bounds of mobile code. Key components of this infrastructure are a certifying compiler for a high-level language, a hierarchy of program logics, tailored for reasoning about resource consumption, and an embedding of the logics into a theorem prover. In this paper, we give an overview of the project's results, discuss the lessons learnt from it and introduce follow-up work in new projects that will build on these results. [ABSTRACT FROM AUTHOR]

There are several tricky aspects of compiling a functional language: what optimisations to perform, how to do them efficiently, and when, or more precisely in what order, the optimisations should be done. The literature discussing the first question is abundant, for the second is somewhat sparse and for the third is almost non-existent. This paper uses the Glasgow Haskell Compiler (GHC) to investigate when the optimisations should be performed to gain maximum benefits, where maximum benefits is defined as shortest runtime, for a given set of optimisations. We focus on GHC, because it has been developed as a test bed for compiler research, but we stress that the techniques are applicable to any other compiler for a functional language. [ABSTRACT FROM AUTHOR]

The article presents a list of computer terminology starting with initial letter "B." The list contains terms such as: "Backbone," "Backdoor," and "Backward-Compatible." Backbone is a core high-speed transmission line, which serves a number of networks. Switches and bridges provide the physical connections between it and the multiple networks for which it provides bi-directional data traffic paths. A backbone is comparable to a main artery in anatomy, which divides into smaller veins and capillaries that might be thought of as switches and networks. Backdoor, is a flaw in the security defences of a system or a network. Backward-Compatible is a hardware component, program object, language compiler, program or operating system that is compatible with an earlier version.

The article presents information on C programming for digital signal processing (DSP) applications. C has become the language of choice for many DSP software developments not only because of its powerful commands and data structures but also because of its portability to migrate between DSP platforms and devices. This article will cover some of the important features of C for DSP applications. The processes of compilation, linking/loading, and execution of C programs differ slightly among operating environments. To illustrate the process one uses a general UNIX system C compiler. C compiler translates high-level C programs into machine language that can be executed by computers or DSP processors. The fact that C compilers are available for a wide range of computer platforms and DSP processors makes C programming the most portable software for DSP applications.

his article presents the introductory matter for the journal "Digital Signal Processing: Laboratory Experiments Using C and the TMS320C31 DSK." It provides a table of the contents, foreword, preface, list of examples and index of topics. In the preface to the journal, its author says that digital signal processors, such as the TMS320 family of processors, are found in a wide range of applications such as in communications and controls, speech processing, and so on. With the introduction of Texas Instruments' third-generation TMS320C3x processor, floating-point instructions and a new architecture that supports features which facilitate the development of high-level language compilers appeared.

An encyclopedia entry for "Software Pipelining" is presented. It refers to a technique used to optimize loops. It is a type of out-of-order execution, only that the reordering is done by a compiler rather than the processor. It receives explicit support from some computer architectures, such as Intel's IA-64 architecture.

An encyclopedia entry for the "Gnu's Not Unix (GNU) Compiler Collection" (GCC) is presented. It is a set of programming language compilers produced by the GNU Project. It is free software distributed by the Free Software Foundation (FSF) under the GNU General Public License (GPL) Lesser general Public License (LGPL).

An encyclopedia entry for "Z88DK" is presented. This refers to a Small C-derived cross compiler for Z80-based computers. It was originally intended for the Cambridge Z88 computer. It accepts many features of the American National Standards Institute (ANSI) C programming language, except multi-dimensional arrays and function pointers.

An encyclopedia entry for "Yet Another Compiler Compiler (Yacc)" is presented. This refers to Unix system tool program for generating C or C++ code for a parser. This command-line tool was developed by Stephen C. Johnson at AT&T. Several modified versions of the program, some of which were written in other programming languages, are in existence.

A reference entry for "Vbcc" is presented. In the context of computer software, this is a highly optimizing portable and retargetable ISO C compiler that supports ISO C according to ISO/IEC 9899:1989. It also supports a subset of the new standard ISO/IEC 9899:1999 (C99).

An encyclopedia entry for "Turbo Software" is presented. It refers to a series of compilers developed by Borland International Inc. such as Turbo Pascal, Turbo C, Turbo C++, Turbo Basic and Turbo Prolog.

An encyclopedia entry for "Turbo Pascal" is presented. It refers to a compiler and Integrated Development Environment (IDE) for the Pascal programming language running mainly on MS-DOS. The compiler was developed by Borland. The name Borland Pascal was used to refer to high-end compiler packages, while the cheaper compiler version was marketed as Turbo Pascal.

An encyclopedia entry for "Turbo C++" is presented. It refers to a Borland C++ compiler and Integrated Development Environment, known for its ultra-high compilation and linkage speed. It was a successor of Turbo C, expanding the compiler as Turbo Pascal 5.5 added object functionality to its predecessors.

A definition of the term "Trace Scheduling" in computer software is presented. The term refers to the optimization technique used in compilers for computer programs. Trace scheduling, a form of global code motion, works by converting a loop to long straight-line code sequence using loop unrolling and static branch prediction.

A dictionary entry for the term "TenDRA Compiler" is presented. The term refers to a C/C++ compiler for POSIX compatible operating systems available under the terms of the BSD license. The compiler uses the Architecture Neutral Distribution Format as its intermediate language. It was originally developed by the British Defence Evaluation and Research Agency.

A definition of the term "Strength Reduction" in computer software is presented. The term refers to a compiler optimization where a function of some systematically changing variable is calculated more efficiently by using previous values of the function. In a procedural programming language, strength reduction applies to an expression involving a loop variable.

A definition of the term "Startup Code" is presented. It refers to a piece of assembly language code that prepares the way for software written in a high-level language. It commonly initializes code and data segments, sets up chip selects and waits states. Most cross-compilers are packaged with startup code that a computer user can personalize, compile, and link with embedded programs.

A definition of the term "Squish of FidoNet" is presented. Squish refers both to the name of a FidoNet mail tossing application originally designed for disk operating system (DOS) and OS/2, and the name of the primary mail storage format in which this application stores FidoNet and other local BBS messages.

A definition of the term "Sparse Conditional Constant Propagation" is presented. It refers to an optimization frequently utilized in compilers after conversion to static single assignment form (SSA). This algorithm simultaneously removes dead code and propagates constants throughout a program. However, it must be noted that it is strictly more powerful than applying dead code elimination and constant propagation in any order or any number of repetitions.

A definition of the term "Source Language" in relation to computer software is presented. It is a computer programming language wherein a source program or source code is written. High-level languages and low-level languages are the classifications of source languages. High-level languages and low-level languages are created as machine code by a compiler or an interpreter program and by means of an assembler program respectively.

A definition of the term "Software Environment" is presented. It refers to the environment that supports an application, including the operating system, the database system, specific development tools or compiler.

A definition of the term "PowerBASIC" is presented. It refers to the BASIC programming language, based on the Turbo Basic. Its syntax is said to be similar to that of FreeBasic, GW Basic, QBasic and Turbo Basic. Its compilers are described to compile to a pure binary form. It is cited that PowerBASIC programs do not require any external dynamic-link library (DLL) to run.

A definition of the term "partial redundancy elimination" is presented. In the context of computer software, this refers to a compiler optimization that eliminates redundant expressions on some paths using a program. Partial redundancy elimination is a form of common sub-expression elimination.

A definition of the term "partial evaluation" is presented. In the context of computer software, this refers to a technique used for program compiling and optimization. A static data is transformed and precomputed into dynamic data through partial evaluation during compiling. Static data is part of the input data known at compile time.

A definition of the term "parallel compiler" in the context of computer software is presented. This refers to a type of computer compiling technique that speeds up the process of compilation on multi-processor machines. Super-computers and other large scale multi-processor machines make use of parallel compilers.

A definition of the term "Open64" is presented. It refers to an open source optimizing compiler for Intel Itanium platform. It was released by SGI and mostly serves as a research platform for compiler and computer architecture research groups.

A definition of the term "Object Code" also known as object file is presented. It is an intermediate representation of code generated by a compiler after it processes a source code file. Object files have compact, pre-parsed code, known as binaries, that can be linked with other object files to generate a final executable library.

A definition of the term "Non-Code Resource" is presented. It is a resource containing the data structures on which the program operates, for example, WIND, DLOG, DITL, or SIZE resources. Non-code resources can be created by using the resource compiler Rez or a resource editor.

An encyclopedia entry for "Loop-Invariant Code Motion" is presented. It is a compiler optimization technique that performs loop-variant code movement automatically to improve execution speed. Loop-invariant code in an imperative programming language is composed of statements which could be moved to before the loop or after the loop without affecting the semantics of the program.

An encyclopedia entry for "Loop Unswitching" is presented. It is a compiler optimization technique that moves a conditional inside a loop outside of it by duplicating the loop's body and placing a version of it inside each of the if and else clauses of the conditional. This improves the parallization of the loop.

An encyclopedia entry for "Loop Transformation" is presented. It refers to a group of loop optimization techniques in computer programming and compiling which helps in improving cache performance and effective use of parallel processing capabilities. Among the common loop transformations are loop interchange, loop tiling or loop blocking and vectorization.

A definition of the term "Loop Splitting" is presented. Also known as loop blocking, it refers to a loop optimization used by compilers to make the execution of certain types of loops more efficient. Loop tiling partitions a loop's iteration space into smaller chunks or blocks to help ensure that data used in a loop stays in the cache until it is reused.

A definition of the term "Loop Optimization" is presented. It refers to the process in computer compiling to optimize loops in the programs. Most execution time of a scientific program is spent on loops, thus, a lot of compiler analysis and optimization techniques have been developed to make the execution of loop faster.

A definition of the term "Loop Inversion" is presented. It refers to a technique in compiler optimization, specifically in loop transformation. This technique changes a standard while loop into a do/while loop wrapped in an if conditional, reducing the number of jumps by two, for cases when the loop is executed.

A definition of the term "Loop Fusion" is presented. It refers to a technique for compiler optimization and loop transformation, which replaces multiple loops with a single one. It is the reverse action to loop fission.

A definition of the term "Local C Compiler" (LCC) is presented. Developed by Chris Fraser and David Hanson, LCC is a small retargetable ANSI C compiler. It can generate code for several processor architectures, including Alpha, SPARC, MIPS, and x86. There is also a Local C compiler back-end that generates MSIL.

A definition of the term "Live Variable Analysis" is presented. Such analysis is performed by computer program compilers to calculate for each program point the variables that may be potentially read afterwards before their next written update.

An encyclopedia entry for the software "Lattice C" is presented. Also known as Lattice Corporation, Lattice C was the first C compiler for the IBM personal computer in 1982. Lattice C was ported to different platforms, like workstations, minicomputers, mainframes, the Commodore Amiga and the Sinclair QL.

A reference entry for "Kylix," a compiler, is presented. It refers to a Linux version of the Delphi and C++ Builder development environments of Borland Corporation for Microsoft Windows. Programmers, through Kylix, can develop software applications for Linux using Object Pascal, C++, or C languages.

An encyclopedia entry for "Jump Threading" is presented. In the field of computing, jump threading is a compiler optimization. In this pass, conditional jumps, conditional jumps in the code which branch to identical or inverse tests are detected and can be threaded through a second conditional test.

A reference entry for "interprocedural optimization" is presented. In the context of computer software, it refers to an integral component in a compilation system that improves computing performance. Interprocedural optimization increases the context available to the optimizing compiler. Procedural calls can also be used by programmers without the concern of hurting execution time.

A definition of the term "instruction selection," in relation to computer technologies, is presented. It refers to a compiler optimization which modifies an intermediate representation of a program into the final compiled code, either in binary or assembly format. Particular focus is given to how an intermediate representation is transformed by instruction selection.

A definition of the term "Inline Expansion" is presented. It refers to a compiler optimization which expands a functional call site into the actual implementation of the function which is called, rather than each call transferring control to a common piece of code. This helps call-site-specific compiler optimizations and reduces overhead associated with the function call.

An encyclopedia entry for "Gnu's Not Unix (GNU) New York University (NYU) Ada Translator" (GNAT) is presented. It is the GNU Ada Compiler based on GNU Compiler Collection (GCC). The front-end and runtime of GNAT are written in Ada. GNAT is licensed under the General Public License.

An encyclopedia entry for "Gnu's Not Unix (GNU) Data Language" (GDL) is presented. It is a free Interactive Data Language (IDL) compatible incremental compiler. The GDL operates existing IDL programs from Research Systems Inc.

An encyclopedia entry for the "Gnu's Not Unix (GNU) Compiler for Java" (GCJ) is presented. It is a compiler for the Java programming language that is [art of the GNU Compiler Collection (GCC). The GCJ can compile Java source code to either Java Virtual Machine bytecode, or straight to machine code for any of a number of central processing unit (CPU) architectures.