DE19954810B4 - Method for generating and debugging a machine program - Google Patents

Abstract

method for generating a debug-enabled Machine program from a high-level programming language, with help a compiler from at least one source code at least one object file is generated, which for debugging required symbol information (11a, 11b) contains and wherein with the aid of a linker (12) the object files to the machine program (13, 14, 18, 19), characterized in that the Linker in the machine program stores a reference table (19), which on the object files with the for needed a debugging Symbol information (11a, 11b) refers.

Description

Technical area

The The invention relates to a method for generating a debug-enabled machine program from a high-level programming language, using a compiler generates at least one object file from at least one source code which is the for needed a debugging Contains symbol information, and wherein using a linker, the object files to a machine program be bound. Furthermore, the invention relates to a method for Debugging a machine program generated by the method mentioned above.

State of the art

On a computer or a microprocessor (CPU) executable programs are usually in a so-called high-level programming language such as Example BASIC, Fortan, Pascal, C, C ++ or the like written. These high-level languages are syntax-based on the human (logical) Mindset and thus allow the programmer one easier understandable and more controllable program generation. Those in such a high-level language formulated instructions are in so-called source text files stored.

Around from the source code a executable on a particular microprocessor machine program To make the source text from the high-level language in the machine language. This translation happens with the help of a so-called compiler. Especially at larger programs contains while the source text usually does not have all the information that for the Create the complete Machine program are necessary. Rather, different parts of the program or needed Subroutines (subroutines) often in different source texts filed or already translated in machine language translated libraries. With the help of the compiler, therefore, a specific source code in the Usually first in translated a so-called object file, which contains the corresponding program part in machine form, the for themselves however, there is no complete executable program yet represents.

The final Rather, the machine program will only be included in a further step Help of a so-called linker from the various involved Object files as well as from routines of the library bound together ( "Linked"). Only through this Left is the complete, executable (executable) Machine program.

There not only for larger programs a completely error-free Formulation of the source text is virtually impossible, are utility programs been developed, with which by a controlled process of the machine program programming errors can be searched. Such programs are known as so-called "debuggers" or "debugging programs". Such Debugging program allows the controlled and in particular step by step Processing the machine program, whereby at any time the correspondence of the currently running Program step followed with the appropriate place in the source code and, if necessary, to let the programmer know the occurrence an error situation with the cause code in the source code can identify. To this correspondence between source code and executable To be able to produce a machine program, the debugger needs it Information about it, which abstract named variables and symbols in the source text which Addresses in the machine program correspond. This information will be provided to the debugger by so-called symbol tables, which the compiler translates creates the source text and appends the object file. The symbol tables become taken from the linker from the object files and the executable Machine program attached.

this Annex of the machine program then uses the debugger to his To perform troubleshooting functions.

In the practice leads the above-mentioned method, however, causes problems because the symbol information often a multiple of the actual program code. hereby On the one hand, the linking process is extended, on the other hand, too the debugging cumbersome, because the debugger big Parts of the address space with the symbol table occupied and often considerable Times used to manage this symbol table and needed or not needed Move parts between different storage areas.

Other concepts and methods for checking source code files and the associated machine program are from the US 5,371,747 A . US 5,093,914 A and US 5,854,924 A known.

Presentation of the invention, object, solution, advantages

task The present invention was therefore a method of production a debugging-enabled Machine program from a high-level programming language and a procedure to debug a machine program, which one faster links and faster debugging allowed.

These The object is achieved by a method having the features of the claim 1 and a method having the features of claim 2 solved.

The Method for creating an executable and debugging machine program a programming language is running doing so off that first with the help of a compiler from at least one source code at least an object file is generated containing the information needed for debugging for example, in the form of a symbol table. With the help of a linker then the object files and possibly program libraries and other sources of information related to the machine program. According to the invention this linking so that the linker in the machine program creates a reference table, which points to the object files with the for a Needed debugging Symbol information refers.

Different as in the prior art so not the complete symbol tables of the individual object files attached to the machine program. Much more This information remains in the object files and in the machine program is merely a reference to the corresponding object file (or their symbol table). Such a reference to a file containing the information is understandable considerably shorter than the corresponding information itself. That is, with the inventive method a considerably smaller and essentially to the actual Program code reduced machine program can be generated. The generation of a complete machine program reduced to the program code is off known in the art (for example, UNIX command "Id-s", that is, left while removing ("strip") the symbol table), however, leads this to machine programs that no longer debugging possible is. With the inventively generated Machine program, on the other hand, can debug with the same functionality as the State of the art be because the debugger over the reference table at any time the required information from the Can obtain symbol tables.

to Invention belongs a method for debugging a machine program, the machine program having a method of the above Art was created. It means that this machine program contains a reference table which on the object files with the for one Needed debugging Symbol information refers. The debugging method according to the invention is characterized in that a debugging program during the Running time of the machine program with the required symbol information Help the reference table only from that object file loads in whose Context the program is currently located.

Basically, one could Debugging a machine program using the procedure outlined above was generated, similar run like a conventional one Debugging. This means, the debugger could first using the reference table from the object files compile all symbol tables and present them constantly, that is in the main memory available hold. The debugger would be in In this case, to catch up with the step, in the prior art the linker by attaching of the symbol tables to the machine program. The advantages over the Prior art would exist in that the link process is not charged with this activity and a considerably shorter Machine program (code plus reference table) is created. In which However, the debugging method proposed in claim 2 is different proceeded and an additional Advantage achieved. The debugging program gets namely the each needed Symbol information dependent targeted by the context in which the program is currently located from the associated Object files. This means, that not constantly the complete symbol table with all information in memory available to maintain and manage, but that only the actual current required Symbol information to be edited. This saves storage space, on the other hand, work generally accelerates as a result of the debugger significantly, as a complex managing a large memory space for the Symbol information is avoided.

In a development of the latter method according to claim 3, the loading takes place for needed a debugging Symbol information from the respective object files via a Cache mechanism. This means, that there is a cache (cache) with fast access which is expected in the following program steps needed Symbol information are stored so that they are available without delay. With the help of such a cache mechanism, it is therefore possible, possibly occurring time disadvantages due to the required access to the Balance symbol tables of object files.

Brief description of the drawings

in the The following is an example of the invention with the aid of the figures explained. Show it:

1 schematically the process of linking and debugging according to the prior art;

2 the inventive process of Linking and debugging.

Best way to carry out the invention

1 schematically shows the by a linker 12 and a debugger 15 programs produced by the prior art. Starting point are in the left part of the figure several object files (object files), each of which is an actual program code 10a respectively. 10b and attached debug data 11a respectively. 11b consist. These object files have been generated by a compiler (not shown) from a high-level programming language. Common compilers, for example from the UNIX environment, store the symbol information needed for debugging in the generated object files. The linker generates from the object files (and possibly program libraries) 12 the executable machine program. This consists of the actual program code 13 and the debug data 14 , which from the linker from the debug data 11a . 11b the object files are generated.

During error checking and troubleshooting in the machine program 13 . 14 with the help of a debugger 15 loads the debugger 15 the symbol information 14 from the machine program into the virtual address space and builds there corresponding data structures (code 16 , Debug data 17 ) on.

There the symbol information is often a multiple of the actual program code is, performs the described Method of the prior art to a significant extension Linking versus working without debug information. Furthermore, the De Bugger occupies large parts with its symbol table the virtual address space. The structure of these tables and the subsequent paging operations (the is called the loading and unloading of programs between memories) worsen the response time response of the debugger for larger programs dramatically.

These problems are avoided with a method of linking and debugging according to the present invention. This procedure is in 2 shown schematically. The inventive method is based on the object files created in the usual way consisting of code segments 10a . 10b as well as debug data 11a and 11b out. The linker 12 however, does not completely read the debug symbol information from the object files. Instead, he puts in the generated machine program next to the actual program code 18 only one table 19 with references and identifiers that reference the corresponding object files and uniquely identify them. As a result, the machine program becomes considerably smaller, as it is no longer the complete debug data 14 but only references to this data are included. Already by this measure, the invention achieves advantages that exist in a reduced machine program and in shortened link times.

Furthermore, the invention includes a debugger 20 which allows debugging of the machine program generated as described above. This debugger 20 At runtime of the machine program, only the symbol table information of those object files in the virtual address space in which the current debug context is located is built. In this case, a cache mechanism is preferably used, which reduces the loading of the symbol information. With this method, the virtual address space used is drastically reduced, especially in the case of larger program systems, and the runtime behavior is thereby significantly improved. There no longer the complete symbol information from the debugger 20 is loaded, a faster start of the debugger is possible. In general, the debugger shows 20 also shorter response times, since the number of paging operations to be performed in the address space is reduced. Finally, with the debugger according to the invention, therefore, a cost saving is also possible because less main memory is required to execute the program on the corresponding computer system.

Claims (3)

Method for generating a debugging-capable machine program from a programming high-level language, wherein with the aid of a compiler at least one object file is generated from at least one source code which contains the symbol information required for debugging ( 11a . 11b ) and wherein with the aid of a linker ( 12 ) the object files to the machine program ( 13 . 14 . 18 . 19 ), characterized in that the linker in the machine program has a reference table ( 19 ), which points to the object files with the symbol information needed for debugging ( 11a . 11b ). Method for debugging a machine program generated in a method according to claim 1, characterized in that a debugging program ( 20 ) at runtime the symbol information required for debugging using the reference table ( 19 ) loads only from the object file in whose context the program is currently located. Method according to claim 2, characterized in that that loading the for needed a debugging Symbol information about a cache mechanism takes place.