JPH0822401A - Method for interrupting program execution and debugging device - Google Patents

Abstract

PURPOSE:To set a function break point where a call function is limited and interrupted. CONSTITUTION:In the break point setting process 12 of a debugging process 1, at least one of the entrance point and exit point of a function is set as the function break point in a break point table 3 on the basis of a break point setting command 21 inputted by a user and a function which calls the function is registered as a call condition function in the break point table. In the instruction executing process 13 of the debugging process 1, it is decided whether or not the function which actually calls the function matches the call condition function when a program is executed and reaches the break point, and the program is interrupted only when the function matches the call condition function, but continued without being interrupted when not.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a program execution interrupting method and a debugging device, and more specifically, it sets a called function or function (hereinafter, may be simply referred to as a function) as a judgment condition in a called function. The present invention relates to a program execution interruption method and a debugging device for interrupting or continuously executing a program at a specified interruption point.

[0002]

2. Description of the Related Art As a first conventional example, in order to debug a program, a user specifies a function name and an entry point or an exit point, or both, so that the entry point or the exit point of the designated function or A program execution interruption method is known in which an interruption point is set in both of them and the execution of the program is interrupted at the interruption point. As a second conventional example, when a user specifies a class name, a breakpoint is set for all functions belonging to the class and functions inheriting the class, and the program is executed at the breakpoint. There is known a method of interrupting program execution for interrupting. Further, as a third conventional example, a function call stack for pushing information of a function that called the function when the function is called and popping the pushed information when returning from the called function is provided. However, using this function call stack, the program is executed when the specified depth (specified by the operand depth) is restored from the current call level (depth of the call relationship = depth of the call stack). A method of interrupting program execution for interrupting is known.

The above-mentioned conventional technique is, for example, "HP-UX".
Symbolic Debugger User's Guide HP9000 C
omputers (Publisher HEWLETT PACKARD, 199
1) ”.

[0004]

When a new function is added to the already-developed program by expanding the function, etc., in order to check the error in using the existing function, the interruption point is added to the existing function. It may be set, and the execution of the program may be interrupted when the new function calls the existing function, and it may be confirmed whether the new function correctly calls the existing function. However, in the conventional technology, if you set a break point in an existing function,
Even if another existing function that does not need to be checked calls the existing function, the execution of the program is interrupted, which causes a problem of inefficient debugging.

In addition, in a program of an object-oriented language, when a class developer debugs the class itself, there is little effect of calls from outside the class, so member functions (methods) belonging to the class are called from within the class. The program execution may be interrupted only when it is interrupted. On the other hand, when debugging a user's program that only needs to use the class, it is not necessary to pay attention to the calling relationship within the class, and the program execution can be executed only when the member function is called from outside the class. Just stop. However, in the conventional technique, if a breakpoint is set in the member function, the execution of the program is suspended without distinguishing the call from inside the class and the call from outside the class.
There is a problem that debugging efficiency is poor.

Therefore, an object of the present invention is to enable efficient debugging in the above situation.
It is an object of the present invention to provide a program execution interruption method and a debugging device for interrupting or continuously executing the execution of a program at an interruption point set in the called function with the called function as a judgment condition.

[0007]

SUMMARY OF THE INVENTION In a first aspect, the present invention is a program execution interruption method for debugging a program having a procedure or function control structure, the procedure or function entry point or exit point. While at least one of the above is specified by the user as a function break point and one or more procedures or functions that call the procedure or function are specified by the user as a call condition function, the specified function break point is When a breakpoint is set and the call condition function is registered in association with the breakpoint, and when the breakpoint is reached during execution of the program, the procedure or function that actually called the procedure or function is Judgment whether or not the calling condition function is met, and depending on the judgment result, execution of the program is interrupted or continued without interruption. Providing program execution is suspended and wherein.

In a second aspect, the present invention is a debugging device for a program having a procedure or function control structure, wherein the procedure or function entry point or At least one of the exit points is set as a function break point, and one or more procedures or functions that call the procedure or function are registered as call condition functions, and a break point setting processing means that executes the program When you reach the point,
An instruction that determines whether or not the procedure or function that actually called the procedure or function matches the calling condition function, and suspends execution of the program according to the determination result, or continues execution without interruption There is provided a debugging device comprising: an execution processing unit.

According to a third aspect of the present invention, in the debugging device having the above structure, when a procedure or function is called, information on the procedure or function that called the procedure or function is pushed, and the called procedure or function is pushed. A function call stack for popping the pushed information when returning from a function is provided, and the instruction execution processing means acquires the procedure or function that actually called the procedure or function from the function call stack. A characteristic debugging device is provided.

According to a fourth aspect of the present invention, in the debugging device having the above-mentioned structure, a command section for designating a kind of an interruption point to be set and a function for designating one or more procedures or functions for setting the interruption point. It is determined that the specification part, the call condition function specification part that specifies one or more procedures or functions that call the procedure or function, and the procedure or function that actually called the procedure or function match the call condition function. There is provided a debugging device characterized in that the interruption point setting processing means receives an interruption point setting command including a conditional operation specifying section for specifying whether to interrupt or continue the execution of the program.

According to a fifth aspect of the present invention, in the debugging device having the above structure, the command point has a function of the conditional operation designating section, and an interruption point setting command not including an independent conditional operation designating section is provided. A debugging device is provided, which is accepted by the break point setting processing means.

According to a sixth aspect of the present invention, in the debugging device having the above structure, the interruption point setting processing means is
There is provided a debugging device characterized in that, when a class is designated in the function designation unit or the call condition function designation unit, all the procedures or functions belonging to the class are processed as designated.

According to a seventh aspect of the present invention, in the debugging device having the above structure, the interruption point setting processing means is
When a class is specified in the function specification part or the call condition function specification part, it is processed as if all the procedures or functions belonging to the class and the procedures or functions belonging to the class inheriting the class are specified. Provided is a debugging device.

According to an eighth aspect of the present invention, in the debugging device having the above structure, the interruption point setting processing means is
There is provided a debugging device, wherein the processing according to claim 6 or 7 is selected according to the contents of the command section.

[0015]

In the program execution interruption method according to the first aspect and the debugging device according to the second aspect, the interruption point is set to the function interruption point designated by the user, and at the same time, the user is made to correspond to the interruption point. Register the specified call condition function. Then, when the breakpoint is reached during execution of the program to be debugged, it is determined whether or not the procedure or function that actually calls the procedure or function matches the calling condition function, and the determination result is Accordingly, the execution of the program is interrupted or is continuously executed without interruption. This makes it possible to suspend the execution of the program or continue the execution of the program at the interruption point set in the called function, using the called function as the determination condition. Therefore, for example, it is possible to interrupt the execution of the program only when the new function calls the existing function, and to prevent the execution of the program from being interrupted even if another existing function that does not require inspection calls the existing function, You can debug efficiently. Also, it is possible to suspend the execution of the program only when calling from within one of the classes or outside the class, and not to suspend the execution of the program when calling from the other,
You can debug efficiently.

In the debugging device according to the third aspect, in the debugging device having the above-described configuration, a function call that pushes information of a procedure or function that called a procedure or function for which an interruption point is set at the time of calling and pops at the time of return The stack is used to acquire the procedure or function that actually called the procedure or function. As a result, the procedure or function actually called can be easily obtained.

In the debugging device according to the fourth aspect, in the debugging device having the above-mentioned configuration, a command section for designating a kind of the interruption point, a function designating section for designating a procedure or a function for setting the interruption point, and the procedure or A call condition function specification part that specifies a procedure or function that calls a function, and a conditional action that specifies whether the execution of the program is interrupted or continued when it is determined that the actually called procedure or function matches the call condition function. A break point setting processing unit receives a break point setting command including a designation section. As a result, the user can accurately instruct the interruption condition by using the interruption point setting command. Further, if the command section includes the function of the conditional operation designating section, the redundancy becomes high and the usability becomes good.

In the debugging device according to the fifth aspect, in the debugging device having the above configuration, the command part includes the function of the conditional operation designating part, and an independent conditional operation designating part can be omitted. As a result, the user can accurately instruct the interruption condition by using the shortened interruption point setting command.

In the debugging device according to the sixth aspect, in the debugging device having the above-mentioned configuration, the break point setting processing means belongs to a class when the class is specified in the function specifying section or the call condition function specifying section. All the procedures or functions to be processed are specified. As a result, the user can specify a plurality of procedures or functions using one breakpoint setting command, which improves usability.

In the debugging device according to the seventh aspect, in the debugging device having the above configuration, the break point setting processing means belongs to a class when a class is specified in the function specifying unit or the call condition function specifying unit. All the procedures or functions to be performed and the procedures or functions belonging to the class that inherits the class are processed as specified. As a result, the user can specify a plurality of procedures or functions using one breakpoint setting command, which improves usability.

In the debugging device according to the eighth aspect, in the debugging device having the above-mentioned configuration, the interruption point setting processing means, when a class is specified in the function specifying unit or the call condition function specifying unit, the contents of the command unit. Depending on, all the procedures or functions belonging to the class are processed as specified, or all the procedures or functions belonging to the class and the procedures or functions belonging to the class that inherits the class are Treat as specified. As a result, the user can selectively use two kinds of designation methods of a plurality of procedures or functions using the class name, which improves usability.

[0022]

EXAMPLES The present invention will be described in more detail with reference to the examples shown in the drawings. The present invention is not limited to this. FIG. 1 is a configuration diagram of a debugging device according to an embodiment of the present invention. This debugging device 1000
Is a memory 1001, a display device 1002, and a CPU 1.
003, an input device 1004, and an external storage device 1005
Is provided. The memory 1001 stores at least the programs of the debug process 1, the input process 2, and the compile process 5 capable of implementing the program execution interruption method of the present invention. In the external storage device 1005,
The source program 4 to be debugged is stored.

FIG. 2 is a conceptual diagram showing the relationship of the processes according to the program execution interruption method of the present invention. The compiling process 5 analyzes the source program 4 and generates an object code 6 and a source information file 7. The source information file 7 includes a row address correspondence table 71, a function information table 72, and class hierarchy information 73. The line address correspondence table 71 is a table showing the correspondence between the line number of the source program 4 and the address on the object code 6 in which the compilation result of the line of that line number is stored. Details of the row address correspondence table 71 will be described later with reference to FIG. The function information table 72 holds information such as function names and function break points. Details of the function information table 72 will be described later with reference to FIG. The class hierarchy information 73 is created when the programming language of the source file 4 is an object-oriented language such as C ++, and holds information on processing units called classes defined in the programming language and inheritance information between the classes. ing. Details of the class hierarchy information 73 will be described later with reference to FIGS. 13 and 14. If the information of the source information file 7 is included in the object code 6, the source information file 7 does not have to be an independent file.

In the input processing 2, the interruption point setting command 21 input by the user from the input device 1004 is debugged 1
Pass to. Debug processing 1 includes command analysis processing 11 and
It includes a break point setting process 12, an instruction execution process 13, a break process 14, and a function call stack 15. The command analysis processing 11 analyzes the breakpoint setting command 21. The break point setting process 12 uses the source program 4, the object code 6 and the source information file 7 according to the break point setting command 21 analyzed in the command analysis process 11 to set the source position and the break condition at which the break point should be set. Is set in the interruption point table 3. Details of the break point table 3 will be described later with reference to FIG. 7. Also, break point setting process 1
2 refers to the row address correspondence table 71, obtains the address of the object corresponding to the source position, saves the instruction in the object code of that address, and replaces it with an interrupt instruction (hereinafter, this instruction is inserted by this replacement). Sometimes an interrupt instruction is called a breakpoint interrupt instruction). The source position is a position of a specific program element (for example, a function call point) on the source program 4, and includes a file number (corresponding to a file having a specific name on a one-to-one basis), a line number, and a column. (Column) number can be combined and expressed.

The instruction execution processing 13 executes the instruction while updating the instruction address of the execution program. When an interrupt due to the interrupt point interrupt instruction occurs during instruction execution, interrupt processing is performed, and then it is determined whether or not the interrupt condition is satisfied. If it is satisfied, the control is passed to the interruption processing 14. Then, when the control is returned from the interruption processing 14,
Resume execution of the instructions below the instruction replaced by the interruption interrupt instruction. On the other hand, if the interruption condition is not satisfied, the execution of the instruction replaced by the interruption point interrupt instruction and the following steps are continued without interruption. The suspending process 14 suspends command execution and waits for an input from the user. Further, the contents of the source file 4 near the current break point are displayed on the display device 1002, and the current break point is shown to the user by a cursor or the like. When the user gives an instruction for continuous execution, control is returned to the instruction execution processing 13.

Three application examples of the present invention will be described below.
For simplification of description, the source position is expressed only by the line number (it is assumed that there is only one function call per line). Moreover, the function name is always handled in the form of "function name ()". Further, the function break point (the break point set at the entry point and / or the exit point of the function) is set only at the entry point.

-Application Example 1-Application Example 1 is an application of the present invention to a source program 4 using a procedural language such as C language.
FIG. 3 is an example 1 of the source program 4. The programming language is C language. Lines 1 to 7 are functions ab
This is the definition of s (), and the function abs () is called at the 15th, 16th and 26th lines. Lines 11 to 18 are the definition of the function absmax (),
On line 27 there is a call to the function absmax ().

FIG. 4 is an example of the row address correspondence table 71. Each entry of the row address correspondence table 71 is created for each execution statement of the source program 4 and is stored in the source position column 711.
Has the line number of the execution statement on the source program 4, and the object position column 712 has the address on the object code 6 where the compilation result of the execution statement is stored. For example, entry 7111 indicates that the compilation result of the executable statement at line number 24 on the source program 4 in FIG. 3 is stored at address 0228 on the object code 6.

FIG. 5 is an example of the function information table 72. Each entry of the function information table 72 is created each time the function is recognized during the semantic analysis of the compilation process 5, and the function number column 72
1 has the function number uniquely assigned to each function, the function name column 722 has the function name, and the function break point column 723 has the source position of the entry point and the exit point of the function (here (Only the entry point), the belonging class number column 724 has the class number of the belonging class of the function (here, it is "0" because there is no belonging class of the function).

In the specific example 1 of the source program 4, the class hierarchy information 73 is not created because there is no class to which the function belongs.

FIG. 6 shows an example of a function breakpoint setting command specified by the user for the source program 4 of FIG. 4 when the debug process 1 is started. "FBREAK abs ()" of the command 101 is the same function break point setting command as in the related art. "FBREAK" is a type of break point setting command that always breaks when a function is called. The operand "abs ()" is the name of the function that sets the break point. The break point setting process 12 of the debug process 1 is
First, using the function information table 72 (FIG. 5), the entry in which the function name column 722 matches is found from the function name “abs ()” of the operand. From the contents of the function break point column 723 of the entry, the source position of the function break point (this is SFB)
And get "4". Next, the row address correspondence table 71 (FIG. 4) is searched, and the entry in which the source position column 711 matches “4” of the source position SFB of the function interruption point is obtained.
From the contents of the object position column 712 of the entry, the object position (this is referred to as OFB) is set to “002
8 "is obtained. Next," 4 "of the source position SFB is registered in the interruption point table 3. Also," 0 "of the object position OFB is registered.
The instruction at 028 "(address) is saved and replaced with an interrupt instruction.

The command 102 "CFBREAK ab
s () main () B "is a breakpoint setting command with a call conditional function according to the present invention. "CFBRE
"AK" designates a break point setting command with a call condition function of a type that, in principle, interrupts when the specified call condition function and the actual call function match, and does not break when they do not match. It is the command section to do. “Abs ()” of the first operand is a function designating unit that designates a function name for setting an interruption point. The "main ()" of the second operand is a calling condition function designating unit that designates a function name that calls the function of the first operand. The third operand "B" is the function "ab" of the first operand.
This is a conditional action designating unit that designates that if "s ()" is called by the function "main ()" of the second operand, it is interrupted, and if it is called by a function that is not the function of the second operand, it is not interrupted. Therefore, when the function main () calls the function abs () at the 26th line of the source program 4 in FIG. 3, the process is interrupted, but at the 15th and 16th lines, the function abs
Even if max () calls the function abs (), there is no interruption. If the third operand is “C”, the function of the first operand is not interrupted if it is called by the function of the second operand, and is interrupted if it is called by a function that is not the function of the second operand.

The command 103 "CFNBREAK a
bsmax () main () C ”is substantially the same as the command 102. However, "CFNBREA
"K" is a break point setting command with a call condition function of a type that does not interrupt in principle when the specified call condition function and the actual call function match, and interrupts when they do not match. This is the command section to specify.
That is, in principle, the command 102 uses the third operand with "B", while the command 1
In principle, 03 uses the third operand as "C".

FIG. 7 shows an example of the break point table 3 created by the break point setting process 12 of the debug process 1 for the break point setting command sequence shown in FIG. Breakpoint table number column 31 of the breakpoint table 3
In, the source position of the break point corresponding to the function of the first operand is stored. The interruption condition column 32 includes a calling function number column 321 and a conditional operation designation column 322. The call function number column 321 stores the function number of the function of the second operand. "0" if there is no second operand
Is stored. The value of the third operand is stored in the conditional operation designation column 322. If there is no third operand,
“N” is stored.

FIG. 8 is a flow chart for explaining a function break point setting procedure by the break point setting process 12 of the debug process 1. In step 801, the function name FN and the interruption condition (second operand and third operand) of the function interruption point setting command are read. In step 802, the function information table 72 is searched and the function name column 7 matching the function name FN is searched.
The entry having 22 is searched for, and the function break point source position BPN is acquired from the function break point column 723 of the entry.
In step 804, the presence / absence of the interruption condition (presence / absence of the second operand and the third operand) is determined. If the interruption condition exists, the process proceeds to step 808, and if the interruption condition does not exist, the process proceeds to step 805. In step 805, the calling function number CFI = 0. In step 806, the conditional action designation F = N. Then, the process proceeds to step 812.

In step 808, the function information table 72 is used to acquire the function number of the function having the function name of the second operand, and set it as the calling function number CFI. Step 80
At 9, the value of the third operand is determined. If "B", the process proceeds to step 810, and if "C", the process proceeds to step 811.
In step 810, conditional operation designation F = B. Then, the process proceeds to step 812. In step 811, the conditional operation designation F = C. Then, the process proceeds to step 812. In step 812, (function break point source position BP
N, the calling function number CFI, the conditional operation designation F) is defined as (break point line number 31, calling function number 321,
It is registered in the conditional operation designation 322).

FIG. 9 shows the instruction execution process 1 of the debug process 1.
It is a flowchart figure explaining operation | movement of 3. In step 900, it is determined whether or not there is an unexecuted instruction at the address of the instruction to be executed. If there is an unexecuted instruction, the process proceeds to step 901, and if there is no unexecuted instruction, the process ends. In step 901, the object code 6 to 1
Take out the instruction. The fetched instruction is the function main
If it is the first instruction in (), the function number of the function main () is pushed onto the function call stack 15. In step 902, it is determined whether the fetched instruction is an interrupt instruction at a break point. If it is the interrupt instruction at the interruption point, the process proceeds to step 903. If it is not the interrupt instruction at the interruption point, the process proceeds to step 907. In step 903, it is determined whether the breakpoint is a conditional function breakpoint with reference to the breakpoint table 3. If it is a conditional function break point, the process proceeds to step 904, and if it is not a conditional function break point, the process proceeds to step 912. In step 904, the interruption point table 3 is referred to, and it is determined whether the conditional operation designation is “B”. If the conditional operation designation is "B", step 905
Go to step 906 if not "B". In step 905, it is determined whether or not the call function number registered in the break point table 3 corresponds to the function actually called. The actual calling function can be known from the function call stack 15 (the function pushed second from the top is the actual calling function). If it is called from the function having the calling function number registered in the interruption point table 3, the process proceeds to step 912. If it is not called from the function having the calling function number registered in the interruption point table 3, the process proceeds to step 907. In step 906, the break point table 3
It is determined whether the function is called from the function having the calling function number registered in. If the function having the call function number registered in the break point table 3 is called, the process proceeds to step 907. If it is not called from the function having the calling function number registered in the interruption point table 3, the process proceeds to step 912.

In step 907, it is determined whether the fetched instruction is a function call instruction. If it is a function call command, the process proceeds to step 908. If it is not a function call command, step 90
Proceed to 9. In step 908, the function call instruction is executed, and then the called function number is pushed onto the function call stack 15, and the process returns to step 900.

In step 909, it is determined whether the fetched instruction is a function return instruction. If it is a function return instruction, the process proceeds to step 910. If it is not a function return instruction, step 91
Go to 1. In step 910, the function call stack 1
The function number is popped from the top of 5, and then a return instruction is executed, and the process returns to step 900.

In step 911, if the fetched instruction is not a break point interrupt instruction, the fetched instruction is executed. On the other hand, when the fetched instruction is the interruption point interrupt instruction, the instruction replaced with the interruption point interruption instruction (the instruction that has been saved) is executed. Also, the interruption process 14
Even when the control is returned from, the instruction replaced by the interruption interrupt instruction (the instruction saved) is executed. Then, the process returns to step 900. In step 912,
Control is passed to the interruption processing 14. If the user instructs continuous execution in the interruption processing 14, control is returned from the interruption processing 14,
Returning to step 911. On the other hand, if the user gives an instruction to stop the processing in the interruption processing 14, the processing ends.

FIG. 10 is a diagram for explaining the push and pop operations of the function call stack 15. The stack state 151 is a state in which only the function number “3” is pushed, and is the state of the 24th line of the source program 4 in FIG. The stack state 153 is a state in which the function number “1” is pushed on the function number “3” in the push operation 152 in step 908, and is the state of the 26th line of the source program 4 in FIG. Stuck state 155
Is popped at the top function number "1" by the pop operation 154 at step 909, and the function number "3"
Is at the top, and the source program 4 in Figure 3
This is the state of the sixth line.

As described above, the user does not only specify the function break point but also limits the call function by the call condition conditional break point setting commands (102, 103) in FIG. 6 and the operation corresponding thereto. Allows you to set conditional function breakpoints in the form. Therefore, the debugging work can be efficiently performed.

-Application Example 2-Application Example 2 is one in which the present invention is applied to the source program 4 using an object-oriented language such as the C ++ language. When the functions are grouped by the relationship such as the class and its member function in the object-oriented language, it is possible to set the break point with the call condition function more effectively than the application example 1. 11 and 12 are examples 2 and 3 of the source program 4. The programming language is the C ++ language. In C ++ language,
Functions include member functions that exist inside the class and non-member functions that exist outside the class. The functions in Example 2 of the source program 4 in FIG. 11 are all member functions. On the other hand, the function mai in the example 3 of the source program 4 in FIG.
The n () and the function f () are non-member functions and do not belong to a specific class.

Since the member function exists in the class, it is necessary to qualify the class name to identify the function. Therefore, the member function is expressed in the format of "class name :: member function name (argument type list)". The argument type list is added because it takes into account the existence of polysemy functions (functions with the same name but different argument types can be defined), but for simplicity of explanation, simply use "()". Only attach.

Example 2 of the source program 4 in FIG. 11 is a so-called class declaration, which defines a class hierarchy for the purpose of being commonly used by various programs, and is usually used as a header file. In the class L, L :: add () is defined in the 104th line, L :: print () is defined in the 105th line, and L :: append () is defined in the class L, respectively. Further, the class iL on the 108th line inherits all members (including functions) of the class L by the specification of ": L". As a function peculiar to the class iL, iL :: addi () is defined on the 109th line, and iL :: printi () is defined on the 110th line. As a result, in the class iL, the three member functions add (), pri of the class L that is the inheritance source are added.
In addition to nt () and append (), addi () and printi () can also be used (called). Similarly, the class sL on the 113th line also inherits the class L, and in addition to the above three member functions, the function ad
ds () can be used. The class pL on the 117th line inherits the class iL. In addition, pL :: addp () is defined in the 118th line as a function peculiar to the class pL. In addition, in the definition of each function, on line 109, from iL :: addi () to L :: add
() Call on line 114, from sL :: adds () to L :: add
There is a call relationship of () call.

FIG. 12 is an example 3 of the source program 4 using the class hierarchy defined in the source program 4 of FIG. 11 as a class library. As an object of each class, an object a of class sL is defined on the 203rd line, an object a of the class L is on the 204th line, and an object ai of the class iL is on the 205th line. As a function call relationship, a function f () calls L :: add () on line 208, and a function main () calls L :: add () on line 212.
Call 213 from the function main () to iL :: addi
() Call on line 214 from function main () to sL :: adds
There is a call to ().

FIG. 13 is a structural example of the class information table 731 for Example 2 of the source program 4 of FIG. Each entry of the class information table 731 is created each time a class is recognized during the semantic analysis of the compilation process 5, has a class number uniquely assigned to each class in the class number column 7311, and has a class name column 7312. Has a class name.

FIG. 14 is a structural example of the inheritance information table 732 for the example 2 of the source program 4 of FIG. Figure 11
And class information table 731 for the example program of FIG.
3 is a configuration example of the inheritance relationship information table 732. Each entry includes an inheritance source class number column 7321 and an inheritance destination class number column 7322. For example, entry 7323 is
It indicates that the class number 2 (class iL) inherits the class number 1 (class L).

FIG. 15 shows a configuration example of the function information table 72 for the example 2 of the source program 4 of FIG. 11 and the example 3 of the source program 4 of FIG. Since the functions from function number 4 to function number 6 are member functions belonging to class L, the content of the belonging class number column 724 is "1".
(Class L). If the function does not belong to any class, the content of the belonging class number column 724 is “0”.

In FIG. 16, when the debug process 1 is started, the user can select the source program 4 of FIG.
10 is an example of a class specification type interrupt condition-specified function interruption point setting command specified for the source program 4 of FIG. Command 201 “CCFBREAK L :: add () iL”
Is a break point setting command with a class-specified type call condition function according to the present invention. "CCFBREAK" means that when a class is specified in the function specification part or the call condition function specification part, all the functions belonging to the class are specified, and the specified call condition function and the actual call function are specified. Is a command section for specifying a break point setting command with a call condition function that, in principle, suspends when the two match and does not interrupt when the two do not match. "L :: add ()" of the first operand is a function designation part. The second operand “iL” is a call condition function designating part. Both the first operand and the second operand can specify a function name or a class name, and when the class name is specified, it means all the member functions that belong to the class. Although there is no third operand, the conditional action designation "B" is assumed.
In the case of command 201, the function “L :: a” of the first operand
If dd () ”is called by a function belonging to the second operand class“ iL ”, it is interrupted, and if it is called by a function that is not a function belonging to the second operand class“ iL ”, it is not interrupted. For example, 1 of the source program 4 in FIG.
If the function add () is called at the 09th line, it is interrupted, but it is not interrupted even if the function add () is called at the 114th line. Similarly, the command 202 “CCFBREAK
In the case of “L iL :: addi ()”, all member functions of the class “L” (here, L :: add (),
L :: append (), L :: print () three functions) are set as function break points, and if these member functions are called by the function iL :: addi (), the function break is made, and the function iL :: addi is stopped. Do not interrupt if called by a function that is not (). If both the first operand and the second operand are functions, the command 102 "CF
BREAK ”or command 103“ CFNBREA
This is the same as when the third operand is set to "B" in "K".

FIG. 17 shows an example of the break point table 3 created by the break point setting process 12 of the debug process 1 for the break point setting command with call condition function of the class designation type shown in FIG. The entry 334 is a break point set by the command 201. When the second operand is designated by the class like this command 201, a plurality of calling function numbers can be designated collectively. Entry 335 is the break point set by command 202. When the first operand is designated by the class like this command 202, it becomes possible to collectively designate a plurality of function numbers for setting break points.

FIG. 18 is a flow chart for explaining the procedure for setting a class-specified conditional function breakpoint at the breakpoint setting processing 12 of the debug processing 1. Step 1801
Then, the first operand bopr and the second operand cop of the breakpoint setting command with a class-specified type call condition function
Read r. In step 1802, it is determined whether the first operand bopr is a class name or a function name based on the presence or absence of “()”, for example. If it is a class name, step 1803
Proceed to. If it is a function name, the process proceeds to step 1805. In step 1803, the class information table 731 (see FIG.
3) is used to obtain the class number BCI of the class name of the first operand bopr. In step 1804, the function information table 72 (FIG. 15) is searched, and the belonging class column 724 is searched.
All the function numbers of the functions whose contents match the class number BCI are acquired, and these are set as the elements of the function number set BIG. Then, the process proceeds to step 1806.

In step 1805, the function information table 72
(FIG. 15) is used to obtain the function number BFI of the function name of the first operand bopr, and this is acquired as the function number set BIG.
The only element of. In step 1806, the function information table 72 (FIG. 15) is searched, and from the contents of the function break point column 723 of each function Fi which is an element of the function number set BIG, the break point line number Pi (i is the index of the element of BPG). ). In step 1807, the second operand cop
Whether r is a class name or a function name is determined by the presence or absence of "()", for example. If it is a class name, the process proceeds to step 1809. If it is a function name, the process proceeds to step 1811. In step 1809, the class number CCI of the class name of the second operand copr is acquired using the class information table 731 (FIG. 13). In step 1810, the function information table 72 (FIG. 15) is searched, and the function number CF of the function whose contents in the belonging class column 724 matches the class number CCI.
Get all I. Then, the process proceeds to step 1812.

In step 1811, the function information table 72
Using FIG. 15, the function number CFI of the function name of the second operand copr is acquired. In step 1812,
The break point line number Pi obtained in step 1806 and the function number CFI obtained in step 1810 or 1811
All the pairs (Pi, CFI) are registered in the interruption point table 3 (FIG. 17). Further, “B” is stored in the conditional operation designation column 322 of the interruption point table 3 (FIG. 17).

The operation of the instruction execution process 13 of the debug process 1 for the interruption point table 3 of FIG. 17 is basically the same as that of the flow chart shown in FIG. However, step 905
And the determination of "whether or not the calling function number registered in the interruption point table 3 corresponds to the actually called function" in step 906 is performed by the number of functions registered in the calling function condition column 321 of FIG. Repeatedly, if any of them matches, it is determined to be “Yes”, and only when they do not match, it is determined to be “NO”.

As described above, by the break point setting command with a class-specified type call condition function of FIG. 16 and the operation corresponding thereto, the user specifies the function for which a break point is to be set or the function to be called condition by the class name. it can. Since the object-oriented language mainly deals with class units, it is possible to efficiently set conditional function break points suitable for the user's intention, which contributes to the efficiency of debugging work.

-Application Example 3-In Application Example 3, the present invention is applied to a source program 4 using an object-oriented language such as C ++, as in Application Example 2 above. When a class is designated instead, all the functions belonging to the class and the functions belonging to the class inheriting the class are processed as designated. As a result, the debugging work becomes more efficient than in the application example 2.
Also in the application example 3, the examples 2 and 3 of the source program 4 of FIGS. 11 and 12 are used. FIG. 19 shows the debug process 1
12 is an example of a break point setting command with a class hierarchy designation type call condition function that the user designates for the source program 4 of FIG. 11 and the source program 4 of FIG. 12 when is activated. Command 301 “CLFNBREAK
"L :: add () L" is a break point setting command with a class hierarchy designation type call condition function according to the present invention.
"CLFNBREAK" is specified when all the functions belonging to the class and the functions inheriting from the class are specified when the class is specified in the function specification part or the call condition function specification part. It is a command part that specifies a breakpoint setting command with a call condition function of the type that continues as a general rule when the specified call condition function and the actual call function match, and interrupts as a rule when they do not match. . "L :: add ()" of the first operand is a function designation part. The second operand “L” is a call condition function designating part. Both the first operand and the second operand can specify a function name or a class name. When the class name is specified, all member functions belonging to the class and the class (indirect inheritance) are specified. It also means the function of all the inheritance source classes (including the one). A class and all classes that inherit it (including indirect inheritance) are called the class hierarchy. Therefore, the class name designated by the first operand or the second operand means designation of the class hierarchy. There is no third operand,
Conditional action designation "C" is assumed. Command 301
In the case of, the function “L :: add ()” of the first operand belongs to the class “L” of the second operand or the function or class “L” of the class “L” that directly inherits the class “L”. "PL" class that indirectly inherits "L"
Continue if called by a function that belongs to, and interrupt if called by a function that does not.

Similarly, the command 302 "CLFNBR
In the case of EAK iL :: addi () iL ”, the function“ iL :: addi () ”of the first operand becomes a function belonging to the class“ iL ”of the second operand or a class“ pL ”that inherits the class“ iL ”. Continue if called by the function to which it belongs, interrupt if called by a function that does not. If both the first operand and the second operand are functions, the command 102 "CFBRE" in FIG.
This is the same as when the third operand is set to "C" by "AK" or the command 103 "CFNBREAK".

FIG. 20 is an example of the break point table 3 created by the break point setting process 12 of the debug process 1 for the break point setting command with the class hierarchy designation type call condition function of FIG. The entry 336 is a break point set by the command 301. Like this command 301,
When the second operand is specified in the class hierarchy, a plurality of calling function numbers can be specified collectively. Entry 337
Is the break point set by the command 302.

FIG. 21 is a flow chart for explaining a procedure for setting a class hierarchy designation type conditional function break point by the break point setting process 12 of the debug process 1. For simplicity of explanation, the function name is specified in the first operand and the second
The class name is specified in the operand. In step 2101, the first operand bopr and the second operand copr of the breakpoint setting command with class hierarchy designation type call condition function are read. In step 2102,
The function information table 72 of FIG. 15 is searched to find an entry having a function name column 722 that matches the function name bopr of the first operand, and the function breakpoint point source position FBI is acquired from the function breakpoint point column 723 of that entry. In step 2103, the class number CCI of the class name of the second operand copr is acquired using the class information table 731 (FIG. 13). In step 2104, the class number CCI is the only element of the class number set CIG. Step 2105
Then, the conditional function number set CFGI is initialized to be empty.

In step 2106, the class number set C
Determine if the element of IG is empty. If it is not empty, the procedure proceeds to step 2107, and if it is empty, the procedure proceeds to step 2112. In step 2107, one element is extracted from the class number set CIG. Let it be the class number CI. After taking out, the class number CI is removed from the class number set CIG. In step 2108, the function information table 72 of FIG.
Is searched, the function numbers are collected from the function number column 721 of the function whose contents of the belonging class number column 724 match the class number CI (that is, the member function of the class of the class number CI), and the function number set CIFIG is created. Step 21
At 09, the function number set CIFIG is added to the conditional function number set CFIG. In step 2110, the inheritance destination class number column 7 of the entry in which the inheritance source class number column 7321 of the inheritance information table 732 of FIG. 14 matches the class number CI.
All the contents of 322 are acquired, and the set DCI of the class numbers of the direct inheritance destination of the class of the class number CI is obtained. In step 2111, a set DCI of class numbers of inheritance destinations
To the class number set CIG. Then, the process returns to step 2106. By repeating the above steps 2106 to 2111 until the class number set CIG becomes empty, the conditional function set CFIG as a set of the function of the class of the class number CI and the class numbers of its direct and indirect inheritance destinations is obtained. You can ask.

In step 2112, the above-mentioned step 21
All of the function break point source position FBI obtained in step 02 and the set of function numbers (FBI and CFIG elements) which are elements of the conditional function set CFIG obtained in step 2109 are registered in the break point table 3 (FIG. 20). To do. Further, "C" is stored in the conditional operation designation column 322 of the interruption point table 3 (FIG. 20).

The operation of the instruction execution process 13 of the debug process 1 for the interruption point table 3 of FIG. 20 is basically the same as that of the flow chart shown in FIG. However, step 905
And the determination of “whether or not the calling function number registered in the interruption point table 3 corresponds to the actually called function” in step 906 is performed by the number of functions registered in the calling function condition column 321 of FIG. Repeatedly, if any of them matches, it is determined to be “Yes”, and only when they do not match, it is determined to be “NO”.

As described above, by the break point setting command with the class hierarchy designation type call condition function of FIG. 20 and the operation corresponding thereto, the user can select a function to set a break point or a function to be a call condition in the class hierarchy. Can be specified. That is, by simply specifying the class name, all the functions included in the class hierarchy having the class as the vertex can be set as the calling function condition. For example, the entire class library can be set as an interruption point simply by specifying the class at the top of the class library. Since the library developer and the user are often separated in the program development using the class library, by using the breakpoint setting by this class hierarchy, an efficient conditional function breakpoint that suits the user's intention can be obtained. Can be set, which contributes to the efficiency of debugging work.

[0065]

According to the program execution interruption method and the debugging apparatus of the present invention, the user can specify not only the function interruption point but also the calling function, and the conditional function interruption limiting the calling function. You will be able to set points. Therefore, the program can be debugged efficiently.

[Brief description of drawings]

FIG. 1 is a configuration diagram of a debugging device according to an embodiment of the present invention.

FIG. 2 is a conceptual diagram showing a relationship of processes according to a program execution interruption method of the present invention.

FIG. 3 is a view showing an example of a source program in application example 1.

FIG. 4 is a configuration diagram of a row address correspondence table in application example 1.

5 is a configuration diagram of a function information table in application example 1. FIG.

FIG. 6 is a view showing an example of a function breakpoint setting command in Application Example 1;

FIG. 7 is a configuration diagram of an interruption point table in application example 1;

FIG. 8 is a flowchart of a function break point setting procedure in application example 1;

FIG. 9 is a flowchart illustrating the operation of an instruction execution process.

FIG. 10 is an explanatory diagram of an operation of a call function stack in application example 1.

FIG. 11 is a first exemplary diagram of a source program in application example 2;

FIG. 12 is a second exemplary diagram of a source program in application example 2;

FIG. 13 is a configuration diagram of a class information table in application example 2.

FIG. 14 is a configuration diagram of a succession information table in Application Example 2;

FIG. 15 is a configuration diagram of a function information table in application example 2.

FIG. 16 is a view showing an example of a breakpoint setting command with a class-specified type call condition function in application example 2;

FIG. 17 is a configuration diagram of an interruption point table in application example 2;

FIG. 18 is a flowchart of a class-specific conditional interrupt function setting procedure in application example 2;

FIG. 19 is an exemplary diagram of a break point setting command with a class hierarchy designation type call condition function in Application Example 3;

20 is a configuration diagram of an interruption point table in application example 3. FIG.

FIG. 21 is a flowchart of a class hierarchy designation type conditional function breakpoint setting procedure in Application Example 3;

[Explanation of symbols]

1 ... Debug processing, 3 ... Break point table, 5 ... Compile processing, 7 ... Source information file, 12 ...
・ Interruption point setting processing, 13 ... Instruction execution processing, 14 ...
・ Interruption processing, 15 ... Function call stack, 32 ...
・ Interruption condition column, 71 ... Row address correspondence table, 72 ...
・ Function information table, 73 ... Class hierarchy information, 321 ...
・ Call function number column, 322 ... Conditional action specification column

Claims (8)

[Claims] 1. A program execution interruption method for debugging a program having a procedure or function control structure, wherein a user specifies at least one of an entry point and an exit point of the procedure or function as a function interruption point, and While the user specifies one or more procedures or functions that call the procedure or function as a call condition function, a break point is set at the specified function break point, and the break point is made to correspond to the break point. Register the call condition function, when the program reaches the breakpoint during execution, determine whether the procedure or function that actually called the procedure or function matches the call condition function, A program execution interruption method characterized in that the execution of the program is interrupted or continued without interruption depending on the result of the determination. 2. A debugging device for a program having a control structure of a procedure or a function, wherein at least one of an entry point and an exit point of the procedure or the function is interrupted based on a breakpoint setting command input by a user. A breakpoint setting processing means for setting a point and registering one or more procedures or functions that call the procedure or function as a calling condition function, and executing the program, and when the breakpoint is reached, the procedure Alternatively, an instruction execution process for determining whether or not a procedure or function that actually calls a function matches the calling condition function, and suspends execution of the program according to the determination result or continuously executes without interruption. And a debugging device. 3. The debugging device according to claim 2, wherein when a procedure or function is called, information of the procedure or function that called the procedure or function is pushed, and when returning from the called procedure or function. A debugging device comprising a function call stack for popping the pushed information, wherein the instruction execution processing means obtains from the function call stack the procedure or function that actually called the procedure or function. . 4. The debugging device according to claim 2 or 3, wherein a command section that specifies the type of the break point to be set and a function specification that specifies one or more procedures or functions to set the break point. Part, a call condition function specification part that specifies one or more functions that call the procedure or function, and a program when it is determined that the procedure or function that actually called the procedure or function matches the call condition function The breakpoint setting command including the conditional action specification part that specifies whether to suspend or continue the execution of
A debugging device, wherein the breakpoint setting processing means receives the information. 5. The debugging device according to claim 4, wherein the command section has a function of the conditional operation designating section, and the interrupt point setting command is not included in the independent conditional operation designating section. A debugging device characterized by being accepted by a means. 6. The debugging device according to claim 4 or 5, wherein the break point setting processing unit assigns a class to a class when the function designation unit or the call condition function designation unit specifies a class. A debugging device characterized by processing all procedures or functions to which it belongs as specified. 7. The debugging apparatus according to claim 4 or 5, wherein the break point setting processing unit is assigned to a class when the function designation unit or the call condition function designation unit specifies a class. A debugging device characterized by processing all belonging procedures or functions and procedures or functions belonging to a class that inherits the class as specified. 8. The debugging device according to claim 4 or 5, wherein the break point setting processing means selects one of the processing according to claim 6 or 7 according to the content of the command section. A debugging device characterized by: