JPH086817A - Program debugging device - Google Patents

Abstract

PURPOSE:To execute a program other than a program to be debugged at an optional address position of the program to be debugged without affecting the program to be debugged by providing a function execution part, a command registration part, and a command initial registration part. CONSTITUTION:The command registration part 13 converts an execution program, functions, and a library 14 to executable format and registers necessary parameters such as the existence of execution program, the relation between arguments and command parameters, and whether or not there are return values in a command table 6. Then the execution program corresponding to a registered command can be executed at an optional address of the program to be debugged without affecting the program to be debugged. Further, the function execution part 11 can utilize the program in the library 14 at an optional address position of the program to be debugged similarly without exerting any influence on the program to be debugged.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention prevents a normal operation of a program by referring to the execution order of the program and the values of a storage device or a register while controlling the execution of the program. The present invention relates to a program debug device used for finding out a defect of a program when the program is broken.

[0002]

2. Description of the Related Art A conventional program debugging device of this type will be described with reference to FIGS. The program debug device is generally realized by using a general-purpose computer system, and a conventional example described below is also configured by using a computer system as described in FIG.

First, an outline of a computer system used in a program debug device including peripheral devices will be described with reference to FIG. In FIG. 9, reference numeral 90 denotes an electronic device including a device such as a CPU (central processing unit), which will be described in detail later, and constitutes a program debug device main body. Reference numeral 97 is an external storage device such as a hard disk for storing a program to be debugged, 98 is a display device for displaying processing results and the like, and 99 is an input device for inputting commands and the like to the program debug device main body 90. Further, the program debug device main body 90 includes a CPU (central processing unit) 91, a ROM 92, a randomly accessible internal storage device 93, a display circuit 95 for displaying characters and the like on the display device 98, and an external storage device. A file input / output interface 94 for controlling 97
It includes an input circuit 96 and the like for receiving inputs such as commands from the input device 99.

The main part of the program debug device is composed of a program. When this program is loaded into the program debug device main body 90, it is stored in the internal storage device 93.

FIG. 7 is a functional block diagram for explaining the function and configuration of a conventional program debug device. In FIG. 7, reference numeral 71 is an input device for inputting commands and the like, and usually a keyboard is used. Reference numeral 72 is an input interface for fetching an input signal from the keyboard as a code into the computer, 73 is a command table search unit for searching a command table 76 described later, and 74 is an actual command searched from the command table 76. Command execution unit for executing the command, 75 is a display unit for displaying the result of command execution, 76
Lists various commands used for debugging, and stores the addresses (addresses) on the internal storage device 78, which will be described later, in which a program for executing the commands is stored in association with each command. A command table, 77 is a memory in which a program to be debugged is stored, 78 is a randomly accessible internal storage device (in the internal storage device 93 of FIG. 9) in which a debugging program that constitutes a main part of the debug device main body is stored. It corresponds).

The command input from the input device 71 is
It consists of one or several alphabetic characters such as S and D (for example, "S" is a command to execute one line of the program to be debugged, "D" is a command to display memory contents), Is input together with the necessary parameters. The command table 76 contains
For example, the address on the internal storage device 78 in which the program for "one-line execution" corresponding to this "S" command is described is described, and the command execution unit 74 reads this address information from the command table. And a necessary program is read from the internal storage device 78 based on the parameters, and necessary processing is performed on the debug target program according to the program.

The processing flow of the conventional example will be described with reference to FIGS. 7 and 8. After starting the program debug device, various necessary initial settings necessary for debugging such as securing necessary memory and clearing memory are performed (step 81), and a command is input from the input device 71 (step 82), and the command table is searched. It is confirmed whether or not the command input in the section is a command indicating the end (step 83), and when the command indicating the end is performed, processing for the end is performed (step 8).
7).

When the input command is a command used for debugging work, the command table retrieving unit 73 retrieves information (address information etc.) necessary for actual work execution from the command table 76, and this is used by the command executing unit. Hand over to 74. The command execution unit 74 reads out a program required for command execution stored in the internal storage device 78 according to the address information and the like, and executes the designated command (step 86). In a normal debugging operation, various parameters are simultaneously input together with a command, and execution is performed according to the parameters. When the work for one command is completed, the result is displayed on the display unit 75, and the operator refers to the displayed result to judge the quality of the program.

[0009]

In the conventional program debug device described above, it is possible to execute a command prepared in advance as a program debug device at any position, but it operates on that device. It was not possible to execute another execution program at an arbitrary address position of the debug target program without affecting the debug target program. A program debug device capable of executing a function existing in the debug target program has also been proposed, but it only checks the function in the debug target program and does not include a function that does not exist in the debug target program. Could not execute library etc. Of course, I could only use the commands that were already built in, and I could not register the commands.

The present invention has been made in view of the above circumstances, and allows another program to be executed without affecting the debug target program at an arbitrary address position of the debug target program, and also allows the library to be executed. An object of the present invention is to provide a program debug device capable of executing the above.

[0011]

In order to solve the above-mentioned problems, according to the present invention, a function execution unit capable of executing a function, a library or the like which does not exist in a program to be debugged at an arbitrary position and a function execution unit are provided. A command registration unit that registers commands so that they can be executed as commands of instructions,
A command initial registration unit is provided for automatically registering a once-registered command after the next program debug device startup.

[0012]

[Function] The command registration unit converts the execution program, function, and library into an executable format, and
The location of the execution program (address on the internal storage device that can be randomly accessed), necessary parameters such as the relationship between arguments and command parameters, and whether or not there is a return value will be registered in the command table. It is possible to execute the execution program corresponding to the registered command without affecting the debug target program at the position. In addition, the function executing unit makes it possible to use the program in the library at any address position of the debug target program without affecting the debug target program.

[0013]

EXAMPLE An example of the present invention will be described with reference to FIG.
The present invention also uses the computer system having the hardware configuration shown in FIG. 9 in the same manner as the conventional example.

FIG. 1 is a functional block diagram for explaining an embodiment of the present invention. In the figure, 1 is an input device composed of a keyboard and the like, 2 is an input interface for taking in an input signal from the keyboard as a machine-readable code into a computer, and 3 is a command table for searching a command table 6 described later. The search unit 4 receives a command from the command table 6 via the command table search unit 3, a command execution unit for actually executing this command, 5 a display unit for displaying the result of command execution, and 6 a debug A command table in which various commands used for work are listed, and this is associated with the address of the internal storage device (corresponding to the internal storage device 93 in FIG. 9) in which a program for command execution is written, 7 is a debug A memory in which the target program is stored (usually an external storage device Is to), these except for command execution designation unit 10 is basically the same configuration as the conventional.

In this embodiment, a command execution designating section 10 for identifying a command from the command table 6 and assigning the command for the next execution, and a function (program) registered in a library 14 described later are further provided. A function execution unit 11 for execution, a command registration unit 13 for enabling execution of a program or the like in the library 14 or a program to be debugged during debugging, a library 14 in which useful programs are registered in advance
The command registration unit 13 (which is usually stored in an external storage device) when the program debug device is restarted
Command registration unit 16 for automatically re-registering the commands registered by the command table 6, an internal storage device for converting a useful program loaded from a library or the like into an executable format and storing it (see FIG. 9). Execution program storage unit 20 provided in the internal storage device 93)
In addition to the above, a termination processing unit 19 for termination processing, an initialization unit 15 for various initializations, an external storage device 17 such as a hard disk, and a result holding unit 12 for holding a function execution result in the function execution unit. Set up.

Further, in the command table 6, in addition to the debug command (command group A) prepared in advance as a program debug device, a command F1 for function execution and a command F for command registration work are provided.
2 is registered, and a new command table area 6'for a newly registered command (command group B) is provided. The commands F1 and F2 are registered in the command table 6 in the same manner as in the conventional example, such as the address in the internal storage device in which the program for executing each command is written, the arguments necessary to execute this program, the return value, etc. This is done by creating a command table corresponding to the parameters of.

The functions of the input device 1, the input interface 2, and the command table search unit 3 are the same as those of the conventional example.
Detailed description is omitted. The command execution designation unit 10 may be a command input from the input device 1 that is a debug command (command group A) attached to the program debug device from the beginning, or a newly added command (command group B). Is a command F1 for function execution, a command F2 for command registration work, or a command Q for termination processing, and the command belongs to the group A or B. If the command is F1, it is sent to the command execution unit 4. If the command is F1, it is sent to the function execution unit 11.
When it is F2, it is sent to the command registration unit 13, and when the command is Q, it is sent to the end processing unit 19.

The function of the command execution unit 4 is similar to that of the conventional example, and a detailed description thereof will be omitted. However, in the case of a newly added command (command group B) described later, a conventional command (command group A) is also used. In the case of), the command table 6 is searched, the corresponding command is read from the new command table area 6 ', and the command is executed.

The function executing section 11 is designed to debug a specific library (program) in the library 14 while
This is for executing without affecting the debugging work, and in the case of this embodiment, it is activated by inputting the command F1. When the function execution unit 11 is activated,
The function executing unit 11 first temporarily saves the value of the register being debugged to a predetermined location in the external storage device or the internal storage device (preprocessing) so as not to affect the program to be debugged, and then in the library. Run a specific program.

To input an actual command, the command F1
A necessary parameter, for example, the name of a specific library to be executed is input together with this, and the specific library is called and the specific library is executed. The result of execution of the specific library is displayed on the display unit 5. Also,
As shown in the embodiment of FIG. 1, the result holding unit 12 may be provided to hold the execution result of the specific library.

When the execution of the function is completed, post-processing for returning the registers and the like to the state before the pre-processing is performed.

The command registration unit 13 is for registering a specific library in the library 14 or a specific program in the debug target program 7 as a command of the program debug device. Similarly to, the preprocessing for not affecting the program to be debugged and the postprocessing after the command registration work are performed.

When the command F2 necessary for starting the command registration unit 13 and the necessary parameters are input, the command registration unit 13 is started according to the input. The command registration unit 13 accesses a specific program in the library 14 or the debug target program 7, converts the program into an executable form, and further calls the program converted into the executable form. A command (for example, B1) is added, and this executable program is stored together with the command in the execution program storage unit 20 provided in the internal storage device. At the same time, this command name and the address information of the execution program storage unit 20 in the internal storage device in which the program corresponding to this command name is stored and the necessary parameters are registered in the new command table area 6 ′ of the command table 6. . To facilitate the command registration work, information about the work may be displayed on the display unit 5.

By registering a command in the command table 6 as described above, a specific command, for example, B1
By inputting from the input device 1, the newly registered program can be executed by the same operation as the command originally registered in the program debug device.

That is, when a newly registered command, for example, B1 is input from the input device 1, the command table 6
Since the command newly created as described above is registered in the new command table area 6 ′ of the command table search unit 3, the command table search unit 3 reads the address of the execution program storage unit 20 in which B 1 is stored from the command table 6 and the necessary Various parameters are read out and sent to the command execution designating section 10. The command execution designation unit 10 sends this to the command execution unit 4. The command execution unit 4 reads out a necessary program or the like from the execution program storage unit 20 based on the sent information and executes it. The execution result is displayed on the display unit 5.

The command registration unit 13 further stores information about the new command stored in the new command table area 6'and the execution program storage unit 20 in a memory, for example, a hard disk, whose contents are not lost even when the power of the apparatus is turned off. Etc. in the external storage device 17.

The termination processing section 19 is for performing post-processing required for finishing the debugging work, and is activated by inputting a command Q from an input device, for example.

The command initial registration unit 16 is provided to enable the newly registered command to be used when the program debug device according to the present invention is started up, and is externally stored when the new command registration process is performed. Device 1
The information about the new command stored in 7, that is, the command itself, addresses corresponding thereto (including necessary parameters) and executable programs are stored in the external storage device 17
This command and addresses are written again in the new command table area 6'of the command table 6, and an executable program is written in the execution program storage unit 20 on the internal storage device together with necessary index information. .

Next, the operation of the embodiment of the program debug device of the present invention shown in FIG. 1 will be described with reference to FIGS. 2, 3, 4, and 5. 2 is a diagram showing the flow of the entire program debug device, FIG. 3 is a flow chart showing command registration processing, FIG. 4 is a flow chart showing function execution processing, and FIG. 5 shows details of command initial registration processing. It is a flowchart which shows.

First, the overall operation of the program debug device will be described with reference to FIG. When the program debug device is started, the initial setting unit 15 performs normal initial setting such as securing necessary memory (step 201), and then enables the command when a new command is registered. Command initial registration is performed (step 202). This command initial registration is performed by the command initial registration unit 16 as already described. As a result, the newly set command can be executed by the same operation as a normal command registered in advance in the program debug device. Details of this processing will be described later with reference to FIG.

When a command for debugging is input (step 203), it is judged whether or not the command is for end processing (step 204), and if it is end processing, end processing is performed (step 205). In other cases, it is determined whether or not a normal command registered in advance in the program debug device (normal processing) is executed (step 206). In the case of normal processing, the processing enclosed by the broken line 210 (step 211, step 21
2, step 213). This normal processing is the same processing as the conventional example, and a detailed description thereof will be omitted here.

If it is not the normal processing, it is judged whether it is the function execution processing (F1 processing) or the command registration processing (F2 processing) (step 207), and the function execution processing (step 208) and the command registration processing (step 208) respectively according to the judgment. Step 209) is performed.

Details of the command registration process (step 209 in FIG. 2) will be described with reference to FIG.

When the command registration process is activated, so-called preprocessing for not affecting the debug target program is executed (step 301), and then it is determined whether or not the function to be registered exists in the debug target program. Is determined by searching the symbol table or the like of the program to be debugged (steps 302 and 303).

If the command exists, it is not necessary to create the function (program) itself, and the process moves to the setting of the command table for writing the necessary information in the command table (step 309). After that, when the program debugging device is started, the command newly registered last time can be automatically registered, so that the contents are not lost even when the power is turned off, for example, in the external storage device 17 such as a hard disk. A file is created and the information registered in these command tables is stored together with the function itself (step 31).
0).

If there is no command in step 303, the function or library must be converted into an executable state and stored in the internal storage device. Therefore, a search is made for a user-created execution program or library in the program to be debugged (steps 304 and 305), and if it is an execution program, the execution file is read from an external storage device or the like (step 306). It is converted into an executable format and stored in the above-mentioned execution program storage unit 20. If it is not the execution program created by the user, the library is read (step 307) and linked (step 308).
Store in 0.

After the functions and libraries are stored in the executable program storage section 20 in the internal storage device in such a form that they can be executed in this manner, various new command names, execution addresses, arguments, return values, etc. necessary for execution are obtained. The information is set in the command table 6 (step 309) and registered in the file created in the external storage device 17 as well (step 3).
10). After that, post-processing (step 311) is performed, and then the processing ends.

Function execution (program execution) using FIG.
The details of the processing will be described. Immediately after the function execution processing is started, so-called preprocessing for not affecting the program to be debugged is carried out (step 41), and then the command argument is checked (step 42). Argument is OK
If so, the function is executed (step 44), the return value is checked (step 45), and post-processing (step 46).
After that, the processing ends. When the argument is not OK, the function is not executed, the post-processing (step 46) is performed, and then the processing ends.

The command initial registration process will be described with reference to FIG. Immediately after activating the command initial registration process, so-called pre-processing is performed to prevent the debug target program from being affected (step 51), and the registration file is read from the file stored in the command registration process (step 52) and registered. Check for command (step 5)
If there is command registration, command registration is performed together with various registration information (step 55). Specifically, the command registration is to read information about the registered command from a file created in the external storage device 17 or the like,
This is to write necessary information in the command table 6 and the execution program storage unit 20 on the internal storage device.

Thereafter, necessary post-processing is performed (step 56), and the command initial registration processing ends. The execution program executed here must be in the form of a subroutine that returns after execution.

FIG. 6 is a memory layout diagram in the internal storage device 93 (see FIG. 9) when the program debug device of the present invention is operated, and FIG. 6A is a memory layout diagram when the program debug device is activated. (B) is a memory layout diagram after command registration, and (C) is a memory layout diagram after command registration and restart.

The memory arrangement after the program debug device is activated will be described. As shown in FIG. 9A, when the program debug device is activated, the operating system is first stored in the internal storage device 93, and the environment setting area is set. Is set. Then, the program for performing the debug process is transferred from the external storage device 97 (see FIG. 9) to the internal storage device 9
3 is also created in the internal storage device 93, which is a work area required for performing debugging work. Further, the program to be debugged (program to be debugged) is stored in the internal storage device 93 from the external storage device 97 at the time of startup or by a command of the program debug device.

Explaining the memory layout diagram at the time of command registration, a newly registered program (execution function) or library (execution library) is arranged in an empty area of the internal storage device 93, as shown in FIG.

The memory allocation at the time of restarting after the command registration will be described. As shown in (C), the execution function and the execution library are registered when the program debug device is started. It is placed next to the debug processing program.

Various modifications can be made in addition to the first embodiment of the present invention described above. For example, a new registration command stored in the new command table area 6 ′ and address information corresponding to it, and an executable function (program) stored in the internal memory 20 are extracted and used as an external memory such as a hard disk. The process of storing in the above file may be performed as a process different from the command registration process, for example, as a part of the ending process. In this case, when the termination process is activated, the newly registered commands and the executable programs created corresponding thereto are first loaded into the new command table area 6'and the internal memory 2.
It is read from 0, stored in a file in the external memory, and then the main body of the program debug device is terminated.

Also, the hardware configuration used in the present application is
Although the input circuit 6 directly connected to the bus is used as shown in FIG. 9, it may be configured to be input from a serial input / output port or the like like a remote debug device from another device. In this case, part of the processing result is displayed on another device.

Further, in the first embodiment, the function which does not exist in the internal storage device is stored in the internal storage device from the external storage device or the like by the command registration process, but it may be searched and stored in the program execution process. . At this time, the function to be stored need only exist in the memory at the time of execution,
After execution, it is deleted from the internal storage device, so that useless memory is not consumed.

[0048]

As described above in detail, in the program debug device of the present invention, the execution program, the function, the library, etc. are programmed at an arbitrary address position of the debug target program without affecting the debug target program. It becomes possible to execute as one of the commands of the debug device, and it becomes possible to change the system environment when debugging the program to be debugged, control the hardware, and refer to various setting states and data.

[Brief description of drawings]

FIG. 1 is a functional block diagram for explaining the configuration and operation of a program debug device according to an embodiment of the present invention.

FIG. 2 is a flow chart for explaining the operation of the program debug device of the first embodiment of the present invention.

FIG. 3 is a flowchart showing a process for command registration according to an embodiment of the present invention.

FIG. 4 is a flowchart showing a process for executing a function according to an embodiment of the present invention.

FIG. 5 is a flow chart diagram for initial registration of a command according to an embodiment of the present invention.

FIG. 6 is a memory layout diagram of an internal memory when the program debug device according to the embodiment of the present invention is activated.

FIG. 7 is a functional block diagram showing a configuration of a conventional example.

FIG. 8 is a flowchart for explaining the operation of the conventional example.

FIG. 9 is a diagram showing a hardware configuration of a conventional program debug device.

[Explanation of symbols]

 DESCRIPTION OF SYMBOLS 1 input device 2 input interface 3 command table search unit 4 command execution unit 5 display unit 6 command table 7 debugged program 10 command execution designation unit 11 function execution unit 12 result holding unit 13 command registration unit 14 library 15 initial setting unit 16 commands Initial registration unit 17 External storage device 19 End processing unit 20 Execution program storage unit

Claims (3)

[Claims] 1. A program debug device comprising an initial setting means, a command input means, a command execution means, and an end means, a function execution means for executing a function registered in a library, a library, and the like. Provided with a command registration means for registering a user-created function as an executable command, and a command initial registration means for automatically re-registering the command registered by the command registration means at startup. A program debug device characterized by being able to execute functions registered in the library at the position of, and functions created by the user. 2. The program debug device according to claim 1, wherein the command registration means itself stores new commands and functions registered by the command registration means in an external storage device. 3. The program debug device according to claim 1, wherein the termination unit stores the new command and function registered by the command registration unit in an external storage device.