JPH0588934A - Debugging system - Google Patents

Abstract

PURPOSE:To flexibly perform interactive debugging in more details by dynamically taking a machine language level debugger into a local process at an arbitrary execution point of a program. CONSTITUTION:An application program 1 interrupts the execution at the time of the occurrence of error or at an arbitrary time to dynamically take a machine language level debugger 4 into its own process by a dynamic link mechanism 2. At this time, an external symbol link mechanism 3 is used to resolve the reference of external symbols to be shared between the program 1 and the machine language level debugger 4. The top level of the machine language level debugger 4 is called to perform interactive debugging in details.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a debugging method for interactively debugging program execution, and more particularly to dynamically incorporating a debugger into a normally executed program to provide a more detailed and optional low level. The debugging method that enables debugging of the.

[0002]

2. Description of the Related Art In a compiler language such as C or Pascal, a source program is compiled to create an executable program. When executing this type of program, if there is an error in the program, a result different from the intended one may be output, or the program may abort during execution, so that it may be necessary to properly debug the program. I can't get the information.

In this case, since it is difficult to find out where the error is in the program in this state, the debugging work may be performed by using a debugger prepared in advance by the system (OS).

First, the system debugger is started, and then the program to be debugged is loaded into the environment of this debugger. Then, this program is executed.

In the environment of the debugger, the debugger monitors the execution of the program one by one, so that the program can be interrupted at the arbitrary program execution time, and the register value at that time can be referred to or the variable value can be changed. Or to debug the program.

However, at this time, since the debugger cannot obtain the information of the source program description if the normal compilation is performed, a symbolic format (for example, if a variable name in the program source is specified, The debugger will display the value of that variable.)
Limited debugging.

In order to debug in the symbolic form, the compile option is specified again to generate this symbolic information, the source program is recompiled, and then the system debugger is used for debugging. There must be.

On the other hand, in an interpreter language such as LISP or BASIC, the interpreter interprets and executes a program, so it is considered that the interpreter corresponds to a system debugger in a compiler language.

Since the interpreter interprets and executes the source program, it is possible to debug in a symbolic format. However, in this case, since it is merely an interpretation and execution mechanism for the source program, debugging at the machine language level cannot be performed.

Also, in LISP and BASIC,
Large-scale programs have been developed and are equipped with a compiler to execute them at high speed. The compiled code cannot be interpreted and executed by the interpreter, so the compiled code cannot be debugged by the interpreter.

Therefore, even in the case of a large-scale program, the source program must be executed by the interpreter for debugging.

Even in the case of an interpreter language, it is possible to use a system debugger to debug the compiled code, but since the processing system often prescribes the format of the compiled code independently, Since it differs from the object file format defined by the system (OS), all functions possessed by the system debugger cannot be used, and debugging must be performed within a limited range of functions. In particular, it cannot be used at all for debugging in symbolic form.

[0013]

When debugging is performed using the system debugger, since it is necessary to execute the program under the environment of the system debugger, more memory is consumed than in normal program execution.

Therefore, when a plurality of developers share one machine, there is a problem that the memory for the process runs out and all the developers cannot debug at the same time.

In particular, when the source program level debugging is performed while holding the symbolic information, the system debugger generates more management information, and this tendency becomes more remarkable.

Further, even in the case of an interpreter language, because of the nature of interpreting and executing a source program, it is impossible to use the machine language level debug function provided by the system debugger, or for compiled code, It has the disadvantage of not having the means to debug.

Further, in the form of debugging using the system debugger, in the case where a program that has been running for a long time suddenly causes an error, in order to reproduce it in the debugger and debug, the debug information There is also a problem in that it is necessary to recompile the program by specifying an option for generating, and then to rerun the program for a long time.

An object of the present invention is to provide a debugging method capable of suppressing the consumption of extra memory consumed by the debugger during program execution.

[0019]

In order to achieve the above-mentioned object, in the debugging method according to the present invention, in the work of interactively debugging the program execution, the program execution is interrupted at any time, A debugger is incorporated into the program execution environment to perform machine language level debugging.

In the interpreter language, if any error occurs, the program execution is suspended, control is returned to the interpreter, and the low-level debugger is loaded.

In the case of a compiler language, an error handling routine for an unexpected error is described in a program, and if an error occurs, the machine language level debugger is loaded based on this error handling routine. ..

[0022]

According to the debugging method of the present invention, the program execution is interrupted at the time when an error occurs or at an arbitrary time, and the debugger is dynamically incorporated into the program execution environment.
Debug interactively.

[0023]

DESCRIPTION OF THE PREFERRED EMBODIMENTS The present invention will be described below with reference to the drawings.

FIG. 1 is a block diagram showing an embodiment of the present invention.

In FIG. 1, 1 is an application program, 2 is a dynamic link mechanism, 3 is an external symbol link mechanism, and 4 is a machine language level debugger.

The application program 1 interrupts the program execution at the time when an error occurs or at an arbitrary time, and uses the dynamic link mechanism 2 and the external symbol link mechanism 3 to operate the machine language level debugger 4. Load into own process.

When the machine language level debugger 4 is loaded into the program 1, thereafter, by using the debugger 4, a detailed low level debugging work can be interactively performed.

In the interpreter language, if any error occurs, the error processing mechanism operates to interrupt the program execution and return the control to the interpreter's supervision.

Therefore, the dynamic link mechanism 2 is called from under the interpreter to load the low level debugger.

If it is a compiler language, the system (O
Using the exception handling mechanism of S), describe an error handling routine for unexpected errors in the program. If an error occurs, call the dynamic link mechanism from this error handling routine to Load the word-level debugger.

Also, when the program is interrupted and the machine language level debugger is loaded, in the interpreted language, the error handling mechanism operates by interrupting from the keyboard. Therefore, the same as when the above error occurs. Therefore, even in a compiler language, the above error handling routine can be described by using the exception handling mechanism of the keyboard interrupt.

Of course, it is also possible to describe in the program such that the execution of the program is interrupted, and the machine language level debugger can be dynamically loaded by the interrupting process.

As shown in FIG. 2, the dynamic link mechanism 2 called from the application program 1 (in the interpreter language, a unique program execution form independent of the system (OS) is often adopted. , The dynamic link function itself is for a compiler language such as C) is often realized as an external program calling mechanism.

On the other hand, for the compiler language (often supported by the OS as a system function), a designated machine language level debugger 4 (this machine language level debugger depends on each language processing system). Since it is possible to provide detailed debugging functions that are familiar with the internal structure, it is effective as a new debugging method, especially for interpreted languages), and is incorporated into the process of the application program.

After that, the external symbol linking mechanism 3 is called to solve the reference address of the symbol that needs to be shared with the language processing system or the application program.

By sharing this kind of external symbol,
For example, it is possible to output information on the internal structure such as how to handle a characteristic stack dependent on a language processing system and how to allocate a data part for high-speed reference.

At this time, if an object file for which debug information has been generated for the application program 1 exists, if the external symbol link mechanism 3 fetches this debug information in the same manner as the system debugger does. , You can also perform symbolic debugging in an environment that dynamically incorporates a debugger.

The low-level machine language level debugger 4 is dynamically incorporated into the execution environment of the application program 1. Therefore, up to the point of incorporation, the program is executed in the environment of the debugger from the beginning.
It saves memory consumption that the debugger will use.

Further, since the debugger can be loaded dynamically, when a problem occurs during the execution of the program, the machine language level debugger can be used while maintaining the environment as it is. for that reason. It is possible to collect information about a program error and discover the cause of the error at the time of the problem, without the trouble of reproducing the problem on the debugger.

With respect to the compiled code generated by the interpreter language, the machine language level debugger has a function possessed by the system debugger, which enables interactive and flexible debugging.

In particular, it is possible to set a breakpoint for a machine language, display register contents at the time of setting a breakpoint, dump output contents of a certain range of memory area, etc., which cannot be done at the source program level. Functions such as changing the contents can be used. this is,
This function is indispensable when creating a language processor or debugging the output code of a compiler.

FIG. 3 shows a processing flow of this system. If control is passed, the dynamic link mechanism 2 is a machine language level debugger 4
Requests the system for the required memory area to call. Then, if the memory can be secured, the debugger is loaded in this area.

First, the text part of the debugger is loaded. Regarding unresolved reference library functions included in the text part, the functions are fetched from each system library and dynamically loaded. Of course, if the library function exists in the application program 1 in which the debugger is loaded, it is used. However, sharing is not mandatory. Sharing saves memory space.

After that, the data section of the debugger is loaded. At this time, the external symbol linking mechanism 3 resolves the address reference to the external symbol whose reference is unresolved in the data part so as to point to the symbol of the same name existing in the application program.

Sharing of this reference is mandatory. This reference is the basis for the debugger to access the application program and the special internal structure of the language processing system. Further, in order to enable sharing of this reference, it is necessary to prepare an address table of these shared external symbols in the application program or language processing system. Alternatively, the definition information of the symbol in the object file of the program is acquired and used. When all external symbol references have been resolved, the debugger load is complete.

Finally, if the top-level command processing mechanism of the dynamically loaded machine language level debugger 4 is called, the machine language level debugger 4 will be executed at the current error point or at the program execution interruption point. Can be used interactively.

[0047]

As described above, according to the present invention, the machine language level debugger can be dynamically incorporated in the program.
It is possible to suppress the consumption of extra memory that was consumed by the debugger during program execution.

Furthermore, since the debugger can be used dynamically even after an unexpected error occurs, it is possible to collect debug information immediately and without waste.

[Brief description of drawings]

FIG. 1 is a block diagram showing a basic configuration in an embodiment of the present invention.

FIG. 2 is a diagram showing a state in which a low-level debugger is incorporated in a program.

FIG. 3 is a flowchart of a process for dynamically loading a machine language level debugger.

[Explanation of symbols]

 1 application program 2 dynamic link mechanism 3 external symbol link mechanism 4 machine language level debugger

Claims (3)

[Claims] 1. In the work of interactively debugging a program execution, the program execution is suspended at an arbitrary time point, and a debugger is dynamically incorporated into the program execution environment to perform a machine language level debugging. A debugging method characterized by. 2. In the interpreter language, if any error occurs, the program execution is interrupted, the control is returned to under the supervision of the interpreter, and the low-level debugger is loaded. The debugging method described in 1. 3. In a compiler language, an error handling routine for an unexpected error is described in a program, and when an error occurs, a machine language level debugger is loaded based on this error handling routine. The debugging method according to claim 1, wherein: