Kylix. Technical Overview of the Kylix Compiler. Introduction. Table of Contents

Transcription

1 Technical Overview of the Kylix Compiler by John Ray Thomas / RAD Tools Product Manager Borland Software Corporation Table of Contents Introduction 1 Native Code Compiler for GNU/Linux 2 Optimizing ELF Emitting Linker 3 GDB-Compatible STABS Debug Info 4 PIC Codegen for Packages and Shared Object Libraries 4 Full-featured Inline Assembler 4 Embedded Resources in the Executable 5 Conclusion 5 Introduction With the highly visual Integrated Development Environment (IDE) of Borland Kylix, it often is easy to overlook one of the most important behind-the-scenes keys to this modern development system. That key, the native code compiler, is absolutely essential to take your programmed logic and turn it into an application that runs natively on your target operating system. The compiler takes the source code a developer has written and turns it into machine code for the target microprocessor. A linker is then used to bring together your compiled unit with the various libraries and units needed to load and run your application on your target operating system. Without a compiler and linker, a Rapid Application Development (RAD) environment would have to rely on other methods of executing a programmer s logic, usually methods that are less efficient and don t perform as well. The Kylix compiler/linker, called dcc, is available on the command-line and is integrated into the IDE. Help output from dcc running in a bash shell Kylix

2 Native Code Compiler for GNU/Linux With the introduction of Kylix, Borland brings to the GNU/Linux platform a Delphi source-compatible, native code compiler. The Kylix compiler is an optimizing compiler that targets the i386 instruction set that favors Pentium scheduling. This compiler gives developers support for the most popular family of microprocessors on the market. Due to an integrated linker and an innovative approach to the front-end/back-end compile stage, the Kylix compiler has an extremely fast build cycle. Rather than emitting an intermediate language from the parse tree in the front-end, the Kylix back-end is passed an intermediate tree, which it then optimizes and uses to generate machine code. Eliminating this additional step results in a remarkable speed gain and provides developers with almost instantaneous feedback on malformed syntax or misused language constructs. In fact, because of this compile speed, Delphi developers often use the compiler just to quickly check syntax. The performance of the Kylix compiler build cycle was recently benchmarked on a Pentium III at 665 Mhz running RedHat 6.2. The file used to perform the benchmark was QComCtrls.pas, which is 402,272 bytes and has 63,546 lines of code. The build cycle for this file took.85 CPU seconds, equating to 74,760 lines of code per second, or 4,485,600 per minute. This blazingly fast build cycle boosts productivity by allowing the developer to jump straight into debugging or testing instead of waiting for the build to finish. Compiler Optimizations A compiler's job is to represent in machine code what a programmer writes in source code. Often there are more efficient ways to represent and execute in machine code what the programmer intended in source code. These efficiencies are called compiler optimizations and often can deliver significant runtime performance advantages. There are several levels of optimizing compilers. Extremely aggressive optimizers can increase application performance significantly but usually produce much larger executables. These optimizers can take dangerous shortcuts which can cause crashes or other anomalies. The Kylix compiler can be classified as moderately aggressive, but it typically produces smaller executables and guarantees that the optimizations will not change the behavior specified by the source code. Compiler optimizations are turned on by default. Register Optimizations Frequently used variables and parameters are automatically placed into CPU registers, thereby reducing the number of machine cycles required to access the variable from memory. The compiler does this optimization automatically, with no the need to specify that certain variables or parameters should be placed into registers. This results in faster and more compact code. The compiler also automatically performs variable lifetime analysis in order to reuse registers. For example, if there are three for loops following each other in a single function, and they use the index variable names i, j, and k, the compiler will reuse the same register for each variable, resulting in faster access and more economical use of CPU resources. 2

3 Call Stack Overhead Elimination When possible, parameters passed to functions or procedures will be placed in CPU registers. Not only does this process eliminate the main memory or cache access similar to the previously described register optimization, but it also means there is no need to set up a stack frame in which to store the values temporarily. This eliminates additional instructions to create and destroy the stack frame so that function calls are even more efficient, providing for faster program execution. Common Sub-expression Elimination As the Kylix compiler translates complex expressions, it ensures that any common sub-expressions (computations needing to be performed more than once) are eliminated. For example, if a pointer is de-referenced repeatedly in a function, the compiler will de-reference it once and reuse it. Thus, the developer can write clear, easy-to-read code, knowing that the compiler will automatically reduce it to its most compact and efficient form. Loop Induction Variables The Kylix compiler automatically uses loop induction variables to speed access to arrays or strings within loops. If a variable is used only to index into an array in a for loop, for example the compiler will induce the variable, eliminating the multiplication operation and replacing it with a pointer that is incremented across items in the array. In addition, if the variable size is 1, 4, or 8 bytes, Intel scaled index address modes are used to provide additional performance benefits. Example of Optimizations The code below illustrates the Kylix compiler s use of register variables and loop induction. The expression Sums[X-1] is reduced to an induction variable a register that is incremented in parallel to the loop variable X instead of being recalculated on each iteration. 3 program example1; {$APPTYPE CONSOLE} var Sums : array [0..500] of Integer; X: Integer; begin Sums[0] := 0; for X := 1 to High(Sums) do Sums[X] := Sums[X-1] + X; writeln(sums[high(sums)]); end. A snapshot of the generated assembly of the loop, as shown from a gdb disassembly, in AT&T format. Comments were added in bold italics and source code in bold for clarity. 0x804b8be <example1+30>: Sums[0] := 0 xor %eax,%eax 0x804b8c0 <example1+32>: mov %eax,0x804d790 0x804b8c5 <example1+37>: for X := 1 to High(Sums) do EDX = X, the loop control variable mov $0x1,%edx 0x804b8ca <example1+42>: EAX = the base memory address of Sums mov $0x804d790,%eax 0x804b8cf <example1+47>: Sums[X] := Sums[X-1] + X Get the value stored at Sums[X-1] mov (%eax),%ecx 0x804b8d1 <example1+49>: Add X to that value add %edx,%ecx 0x804b8d3 <example1+51>: Store the sum in Sums[X] mov %ecx,0x4(%eax) 0x804b8d6 <example1+54>: Increment the loop control variable inc %edx 0x804b8d7 <example1+55>: Increment the induction variable add $0x4,%eax 0x804b8da <example1+58>: Test for loop end cmp $0x1f5,%edx 0x804b8e0 <example1+64>: jne 0x804b8cf <example1+47> Optimizing ELF Emitting Linker The Kylix ELF emitting linker performs with extremely fine granularity when linking code and data into an ELF executable file. For example, when the Kylix linker pulls in a unit to resolve an external symbol, only the code associated with that symbol is linked in, not the whole unit. Since only referenced code, down to statement, is linked, the result is extremely small executables regardless of the size of units linked in.

4 Due to its integration with the compiler, the Kylix linker benefits from access to compiler symbol info and will therefore optimize out unused code, a process also known as dead code elimination. The integration of the linker also shortens the build cycle considerably. The Kylix linker can link in.o files (no C++ classes), meaning that a Kylix developer has direct access to existing and emerging libraries that can build these object files from their sources. GDB Compatible STABS debug info As many seasoned Linux developers prefer to use gdb to debug their applications, the Kylix linker also supports the generation of STABS debug information. While the Kylix debugger is more powerful and easy to use than gdb, support for the latter provides developers with immediate access to their familiar debugging environment. In fact, the assembly code on the previous page was disassembled with gdb. PIC Codegen for Packages and Shared Object Libraries The Kylix linker is capable of creating shared object libraries. PIC (Position Independent Code) support was developed to work with the ELF loader, in a way that the loader prefers. PIC shared object libraries can take less time to load than their Windows PE-loaded counterparts because there are no module address collisions and fixups to resolve. With Borland Delphi 3, Borland introduced the notion of packages. Packages, much like shared object libraries, contain sets of units in compiled machine code. Package technology, however, allows the developer to partition an application into multiple shareable modules, at link time, without affecting the application source code. With packages, there is no need to explicitly export symbols, so developers do not need to hassle with writing cryptic export code. Packages supply memory savings, promote code sharing across multiple applications, and provide an economy of scale. Linker options dialog showing STABS option 4 Full-featured Inline Assembler Kylix introduces a new, full-featured, inline assembler. This assembler supports all instructions found in the Intel 386, the Intel 486, the Intel Pentium, the Intel Pentium Pro and the Intel Pentium III. All Single- Instruction/Multiple-Data (SIMD) instructions, including MMX and SSE(KNIS), are available. Additionally, the new inline assembler supports the AMD 3DNow! and Enhanced 3DNow! SIMD instructions. It enables knowledgeable programmers to take advantage of these latest technologies, reaping performance benefits for their applications. Thanks to the built-in nature of the assembler, a Kylix developer would have full access to variable names as if he or she were writing in the Kylix native language. Further, a new assembler directive was added to assist the Kylix developer who needs to call into an object s vtable hierarchy (without calculating the offset or walking the

5 vtable) with the VMTOffset function. With this support, a Kylix developer can load a virtual function pointer into a register with a line of Intel i386 assembly code similar to the following: MOV EAX, VMTOffset TMyObject.virtual_method Embedded resources in the executable Kylix offers developers the ability to embed resources such as strings, icons, bitmaps, and other data into an application s executable, allowing developers to deploy a single executable file. Confining resources in a single executable file simplifies installation chores for the developer and reduces the chance of failure during program execution to external missing, damaged, or inaccessible support files. Kylix embeds resource data into the executable file using custom sections conforming to the ELF specification. Standard ELF inspection tools, such as objdump, can display the resource data in these ELF sections. A major advantage of Kylix embedded resources over traditional data embedding techniques is that Kylix resources can be replaced without re-linking the executable. Kylix includes resbind, a developer utility to rip and replace resources in an executable file. Resbind makes it easy to translate the user interface of an application to other user languages (German, French, etc.) and still have only a single executable file to deploy for any given locale. Alternatively, this technology provides the opportunity to build and deploy resource shared objects, giving the developer another method of seamless and extremely flexible localization. Internally, Kylix s Object Pascal language and RTL have built-in support for translatable resource strings and form layout resources. Low-level access to embedded resources is provided via the Kylix RTL functions, which are similar to the Windows resource access APIs. Conclusion Kylix is the first GNU/Linux RAD tool to bring both productivity and performance to GNU/Linux development. Borland brings together a unique combination of a visual two-way system, hundreds of CLX components, and a fully integrated and powerful debugger, all augmenting and supporting its lightning-fast compiler. With Kylix, GNU/Linux application developers finally realize the benefits of RAD without having to sacrifice performance. 100 Enterprise Way Scotts Valley, CA Made in Borland. Copyright 2001 Borland Software Corporation. All rights reserved. All Borland brand and product names are trademarks or registered trademarks of Borland Software Corporation in the United States and other countries. All other marks are the property of their respective owners