JPH07295857A - Program debug method - Google Patents

Abstract

PURPOSE:To provide a debug method which can effectively perform the debug jobs. CONSTITUTION:A history storage instruction is set to the function which constructs a program to be debugged in order to store the function and the parameter inputted to the function in a history information area (STEP 1). Then the program is run and a storage history number is given to the function including the parameter and stored in the history information area (STEP 2). If the abnormality occurs during the run of the program to be debugged, the run of this program is stopped and the count value of a storage history number counter is confirmed (STEP 3). The number obtained by subtracting the prescribed value from the count value of the counter is set at a break counter (STEP 4). Then the program is run again and then stopped when the storage history number is coincident with the value set at the break counter (STEP 5).

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a program debugging method. In recent years, various devices have been equipped with a processing device, and complicated and advanced functions have been realized by software. If a program bug occurs after such various devices enter the actual operating state, the influence of the device operation stop or the like becomes large. Therefore, it is necessary to remove as many bugs as possible by debugging immediately after the program is developed, and a debugging method capable of efficiently performing such debugging is required.

[0002]

2. Description of the Related Art FIG. 6 is a diagram for explaining the collection of traveling history in a conventional example. The figure is an example of a program stored as history information in the history information area of the storage device, and among the functions (Function, shown as Func in the figure) that make up the program, all executed functions are recorded in the order in which they were executed. It was done.

As a method of collecting the travel history of other programs, it is also practiced to extract and store only the JUMP history.

[0004]

A program is composed of a plurality of functions, and executes designated processing based on input parameters. Therefore, when analyzing the cause of the program operation abnormality, all the executed functions are analyzed, but since the history information in the conventional example does not record the parameters input for each function. , It is unknown what each function did,
It takes time to analyze the cause of the abnormality, which is not efficient.

Further, when the history information is collected only for the JUMP history, the traveling route of the program can be analyzed, but since there is no parameter, there is insufficient information about what operation each function has performed, and the analysis is performed. Is difficult.

Further, when performing a reproduction test of abnormality,
It is necessary to stop the execution of the program in a function that is several steps before the function in which the abnormality was detected, and to analyze it in detail, including the parameters input at that time. Therefore, in order to stop the program by the function executed before the specified number “n” of functions that have stopped due to an abnormality,
After analyzing the execution route of the program, it is necessary to find a function "n" before the function in which the abnormality is detected and set a breakpoint there.

The present invention seeks to realize a debugging method capable of efficiently debugging a program.

[0008]

FIG. 1 is a diagram for explaining the principle of the present invention. The figure shows the program debugging method,
In STEP 1, a function that constitutes the program to be debugged is set with a history storage instruction that stores the function and the parameters input to the function in the history information area of the storage device. In STEP 2, the program to be debugged is run and the input parameters are set. The stored history number is given to the attached function and stored in the history information area. In STEP 3, when an abnormality occurs during the running of the program to be debugged, the running of the program is stopped and the count number of the stored history number counter is increased. To confirm.

Then, in STEP 4, the number obtained by subtracting a predetermined count value from the count value of the storage history number counter is set in the break counter, and in STEP 5, the program to be debugged is run again, and the storage history number is set in the break counter. By stopping the running of the program when the values match, the running of the program can be stopped by an arbitrary function before the function in which the abnormality has occurred, and the program can be analyzed.

[0010]

FIG. 2 is a diagram for explaining the operation of the present invention.
(A) shows a function and parameters input to the function (* in the figure) for multiple functions that make up the program to be debugged.
Is stored in the history information area (a history storage instruction in the figure is shown as Set Call-history) is set.

FIG. 1B shows an area of a random access memory (hereinafter referred to as a RAM) of a storage device of a device for debugging a program. The RAM area includes a program area 21 in which a program to be debugged is stored and a program area. A history information area 22 for storing traveling history is provided.

Each time the function of the program to be debugged is executed, the history information area 22 includes the history information area 2 including the function and the parameters input to the function.
While storing the data in No. 2, the storage history number counter (the count value of the storage history number counter in the figure is shown as Call-No) is counted by "+1", and the number is written. When an abnormality occurs, the running of the program is stopped and the value of the storage history number counter is set in the storage history maximum counter at that time.

When a program abnormality is analyzed, a value obtained by subtracting a predetermined value from the value of the storage history maximum counter is set in the break counter, and then the program is run for the second time. At this time, the break counter and the stored history number counter are compared, and the program running is stopped when they match, so it is possible to easily refer to the program running route and parameters up to an arbitrary function, and to debug. The efficiency can be increased.

[0014]

DESCRIPTION OF THE PREFERRED EMBODIMENTS FIG. 3 is a block diagram illustrating a debug system according to an embodiment of the present invention. In the figure, 10 is a processing device for debugging a program, 20 is a storage device having a program area 21 in which a debug program is written and a history information area 22, 31 is a storage history number counter,
32 is a maximum storage history counter, 40 is a break counter, 50 is a keyboard, 60 is a display, and 70 is a disk device for storing various data.

In the figure, the program to be debugged is written in the program area 21. The history information area 22 has the configuration described in FIG. Here, the keyboard 50 is for inputting a command for debugging to the processing device 10, and the storage history number counter 31 is a counter for counting "+1" each time the function is executed. Yes, maximum storage history counter 3
2 is a counter that stores the count value of the storage history number counter 31 when an abnormality occurs, and the break counter 40 is a counter that specifies a stop position at which the program is stopped in order to analyze the program. The display 60 is a display that displays the state at that time.

FIG. 4 is a flow chart of the execution history storage instruction of the present invention. The function will be described below in accordance with STEP of the flowchart. The operation specified by the function and the parameter is executed, and the history storing instruction is called to store the history information of the function name and the parameter in the history information area 22.

The storage history number counter 31 (the count value of the storage history counter 31 in the figure is shown as Call-No) is counted by "+1". It is determined whether or not the break counter 40 has a stop position specified.

If the stop position is not specified in the break counter 40, it is First-Run, and it is determined whether or not the result of executing the function is normal. If normal, the next function is executed and the next function is executed. wait.

If the result of executing the function is negative, the value of the storage history number counter 31 at that time is stored in the maximum storage history counter 32. Stop running the program.

If there is a designation of the stop position in the break counter 40, it is Second-Run,
Value of stored history number counter 31 and break counter 40
It is determined whether or not the values match with each other, and if they match, the program has advanced to the designated stop position, and the process advances to step 1 to stop the program running. Storage history number counter 31
If the value of and the value of break counter 40 do not match,
If the execution result of the function is normal, the process ends and the execution of the next function is waited for.

By the function of the history storage instruction described above, the FIR
In st-Run, a function including parameters is stored in the history information area 22, and in Second-Run,
Stop the program running by the specified number of previous functions where an error occurred and analyze the cause of the error.

Here, the setting of the break counter 40 is
The value is set by subtracting the specified value "n" from the count value of the storage history maximum counter 32. However, if "n" is not specified, the default is the specified number of abnormal function (for example, "3"). Alternatively, it is possible to set an arbitrary number such as "4"), and execution of the program can be stopped by the previous function.

FIG. 5 is a diagram for explaining the traveling history of the embodiment of the present invention. In the figure, the stored history counter 31 has a count value of "54" and an abnormality has occurred.
This is an example of stopping the running of the program and collecting history information.

(A) shows the history information stored in the history information area 22 in the First-Run. The function and the parameters input to the function are stored in the history information area 22 every time the history storage command is executed. After being stored, the count value of the storage history number counter 31 is updated.

Here is an example in which an abnormality occurs in the 54th function. At this point, the running of the program is stopped,
Collection of history information in First-Run is completed,
The count value “54” of the storage history number counter 31 is stored in the maximum storage history counter 32.

(B) shows history information stored in the history information area 22 in Second-Run. here,
This is an example in which the stop position designation number n = 2 is designated, and “54-2” = “52” is set in the break counter 40.

When the program is run, Fi
As with rst-Run, each time a history storage instruction is executed, the function and the parameters input to the function are stored in the history information area 22, and the count value of the storage history number counter 31 is updated by "+1". To go. At this time, since "52" is set in the break counter 40, the Second-Run is set to the break counter 4
It stops when 0 becomes "52".

In this way, by displaying the travel history stored in the history information area 22 on the display 60, for example, the cause of the abnormality can be efficiently analyzed.

[0029]

According to the present invention, when the program is debugged, the running route of the program before the occurrence of the abnormality,
The contents of the input parameters to each function and the execution of the program can be stopped in any function before the execution of the function in which the error occurred, and the detailed operation up to the function in which the error occurred can be checked. Therefore, the efficiency of program debugging can be improved.

[Brief description of drawings]

FIG. 1 is a diagram illustrating the principle of the present invention.

FIG. 2 is a diagram for explaining the operation of the present invention.

FIG. 3 is a block diagram illustrating a debug system according to an embodiment of the present invention.

FIG. 4 is a flowchart of a history storage command according to the embodiment of this invention.

FIG. 5 is a diagram illustrating a travel history according to the embodiment of this invention.

FIG. 6 is a diagram illustrating collection of traveling history in a conventional example.

[Explanation of symbols]

 10 Processor 20 Storage Device 21 Program Area 22 History Information Area 31 Storage History Number Counter 32 Storage History Maximum Counter 40 Break Counter 50 Keyboard 60 Display 70 Disk Device

Claims (1)

[Claims] 1. A method for debugging a program, wherein a history storing instruction for storing a function and a parameter input to the function in a history information area of a storage device is set in a function constituting a program to be debugged. (STEP
1), the program to be debugged is run, a storage history number is given to a function with an input parameter and stored in the history information area (STEP 2), and when an error occurs during running of the program to be debugged, The running of the program is stopped, the count number of the storage history number counter is confirmed (STEP 3), the number obtained by subtracting a predetermined value from the count value of the storage history number counter is set to the break counter (STEP 4), and the debug target 2. The program debugging method, wherein the program is run again, and when the stored history number matches the value set in the break counter, the running of the program is stopped (STEP 5).