JPH06290077A - Method for setting up interruption point of program execution - Google Patents

Abstract

PURPOSE:To reduce user's load and to improve debugging efficiency by setting up interruption points in all access points by the specification of a function. CONSTITUTION:Compiling processing 5 analyzes a source program 4 and generates function access information 72. Debugging processing 1 finds out all positions on an object code 6 for accessing a function specified by an interruption point setting command 21 inputted from input processing 2 based upon the information 72, saves the instruction codes of these positions and substitutes interruption instructions for the saved instruction codes. This interruption point setting method is especially effective for the debugging of a program having various kinds of functions and written by language capable of executing implicit function access or dynamic binding.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a program execution breakpoint setting method, and more particularly, to a breakpoint setting method for setting a breakpoint (breakpoint) at which program execution is suspended during debugging.

[0002]

2. Description of the Related Art In order to debug a program, the execution of the program is interrupted at a predetermined time point and the contents of various variables are often examined. Therefore, the debugger has a function of setting a break point. Conventional break point setting methods include setting break points by the line number of the source program, setting break points on a line-by-line basis at the display position of the source program, or by using absolute addresses in the object program. A method of setting is known. For such a breakpoint setting method, see "UNIX System".
V Programmer Reference Manual Second Edition Release 3.0 (Publisher: UNIX System Laboratories Pacific; Publisher: Kyoritsu Publishing 1985) pp.117-126 "
There is a detailed disclosure in the explanation of the SDB command.

As another example of the conventional breakpoint setting method, there is known a function breakpoint setting method for designating a function name and an entry point, an exit point, or both of them. In this case, the execution of the program is suspended when the control is transferred to the entry point or the exit point of the designated function. In a procedural language, a function (including what is called a procedure) is a unit of processing in a control structure, and thus this function breakpoint setting method is useful. In addition, you can specify a break point without checking the line number or absolute address.
This function breakpoint setting method is useful. Further, as still another example of the conventional breakpoint setting method, as in the C ++ language, a function ambiguity function (the same name is given to a plurality of functions,
For a language that has a function to select and call a target function according to the type of argument, just specify one function name,
There is known a method of setting the above-mentioned function break point in the ambiguous function group. Regarding such a breakpoint setting method, refer to "HP-UX Symbolic Debugger Users's
Guide HP9000 Computers (Publisher HEWLE
TT PACKARD 1991) pp.5-48-5-51 ".

[0004]

In the above-mentioned conventional function interruption point setting method, the interruption point is limited to the entry point or the exit point of the function. That is, the execution of the program is interrupted when the control is transferred to the entry point or the exit point of the function. However, depending on the language of the source program, the situation at the function call point immediately before that may be more important than the situation at the time when control is transferred to the entry point of the function. For example, when the language has a function of dynamically binding functions, and a function selected according to the type of an object at runtime is called from a plurality of functions with the same name (for example, a virtual function in the C ++ language). In the case), it is important which function is called at the call point, that is, which function is bound at run time. Therefore, it is necessary to interrupt at the function call point. In particular, it is up to the user to check the function group that is the target of the specific dynamic binding, and to check the call point where the dynamic binding is performed, and there is a high possibility that a bug will occur due to misuse. Need to interrupt at. Also, when there is an implicit function call as a language function, it is necessary to interrupt at the function call point.

However, conventionally, when it is desired to interrupt at the function call point, the user investigates the line number of the function call point,
It was necessary to set a break point for that line number. However, there is a problem that it is burdensome for the user to analyze the source program and investigate the line number of the function call point. Also, since there are generally multiple function call points in a program, even when setting a break point for a line number,
There is a problem that the user is burdened. SUMMARY OF THE INVENTION It is therefore an object of the present invention to provide a program execution breakpoint setting method that can easily set a breakpoint at a function call point without imposing a burden on the user.

[0006]

According to the present invention, there is provided a feasibility information extraction step of analyzing a program to extract feasibility information for a specific processing unit of the program, and an executability for the specific processing unit of the program. And a step of setting a break point at one or more positions associated with the program based on the executability information and the break point setting command. There is provided a program execution breakpoint setting method characterized by including a breakpoint setting step.

[0007]

In the method of setting a program execution break point according to the present invention,
When a specific processing unit of the program is, for example, a function call, the feasibility information extraction step extracts the position information of the function call point in the program as the feasibility information. Then, the interruption point setting command reception step receives, for example, a user inputting a function call interruption point setting command, and shifts control to the interruption point setting step. The break point setting step fetches the position information of the function call point in the program from the executability information as one or a plurality of positions associated with the program, and sets break points at those positions. Thus, it becomes possible to easily set break points at a plurality of function call points, and the burden on the user is reduced.

[0008]

The present invention will be described in detail below with reference to the embodiments shown in the drawings. The present invention is not limited to this. First Embodiment FIG. 1 is a block diagram of a debugging device for carrying out the program execution break point setting method of the present invention. The debugging device 1000 includes a memory 1001 and a display device 100.
2, a CPU 1003, an input device 1004, and an external storage device 1005. The memory 1001 stores a program for a compile process and a debug process capable of implementing the program execution breakpoint setting method of the present invention.

FIG. 2 is a block diagram of a processing group according to the program execution interruption point setting method of the first embodiment 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 as in the case of the conventional technique. Details of the row address correspondence table 71 will be described later. Further, the source information file 7 includes the function call information 72, which is different from the conventional technique. Details of the function call information 72 will be described later. 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.

The debug processing 1 performs debugging using the break point table 3, the source program 4, the object code 6, and the source information file 7 in accordance with the break point setting command 21 input by the user from the input processing 2. The debug process 1 includes a command analysis process 11, a breakpoint setting process 12, an instruction execution process 13, and a break process 14.
And interruption point display processing 15.

FIG. 3 shows an example of the source program 4.

The programming language is C language. The 1st to 7th lines have the definition of the function abs, and the 15th and 16th lines have the call to the function abs. Also, the definition of the function absmax is on lines 11 to 18, and the definition of the function absmax is on line 26.
There is a call to smax.

FIG. 4 is an example of the row address correspondence table 71. Each entry of the row address correspondence table 71 has a line number on the source program 4 as the source position 711, and on the object code 6 where the compile result of the source program portion of the line number is stored as the object position. Have an address. For example, entry 7111 is line number 2 in source program 4 in FIG.
4 corresponds to the address 228 on the object code 6. The source position is the position of a specific program element on the source program, and is generally expressed by combining the source program number and the line number and column number on the source program. However, in the present invention, the method of expressing the source position is not an essential matter. Therefore, for simplification of the explanation, it is assumed that there is one source program and there is only one function call per line. It can be specified only by the line number.

FIG. 5 is an example of a call information table 721 included in the function call information 72. Each entry of the call information table 721 has a line number on the source program 4 as call source position information 7211, and a function number 7212.
Has the function number (see FIG. 6) representing the function called by the line number.

FIG. 6 is an example of the function information table 722 included in the function call information 72. Each entry of the function information table 722 has a number arbitrarily assigned to the function as the function number 7221, the name of the function defined in the source program 4 as the function name 7222, and the function attribute 72.
Reference numeral 23 has information on various attributes (properties) of the function that are clarified in the compile processing 5. However, since the function attribute 7223 is not used in the first embodiment, it is blank (used in the second embodiment described later). In addition, if the information of the function information table 722 is included in the call information table 721, it does not have to be an independent table.

Each entry of the call information table 721 and the function information table 722 is created every time a function or a function call is recognized during the semantic analysis.

FIG. 7 is a flow chart of a process in which the compile process 5 creates the function call information 72. This process is a part of the front part (the lexical syntactic and semantic analysis phase) of the compilation process 5. Step 600
Then, the function number counter CFI is initialized to "0".
Further, the source line number counter SLN is initialized to "0". In step 601, one line of the source program 4 is read and the source line number counter SLN is incremented. In step 602, it is determined whether the source program 4 is the last one. If it is the last one, the process is terminated. If not, the process proceeds to step 603. In step 603, syntactic and semantic analysis is performed. This includes the output of an intermediate file (intermediate language, symbol table, etc.), and directly corresponds to the processing of the front part in the conventional technique.

In step 604, it is determined whether the line is a function definition. If it is a function definition, the process proceeds to step 605. If it is not a function definition, the process proceeds to step 607. Step 60
In 5, the function number counter CFI is incremented. In step 606, an entry is created in the function information table 722, and the value of the function number counter CFI is set to the function number 72.
21, the function name is stored in the function name 7222, and the function attribute is stored in the function attribute 7223. However, since the function attribute 7223 is not used in the first embodiment, it is blank (used in the second embodiment described later). Then, the process returns to step 601.

In step 607, only the function call is judged. If the function is called, the process proceeds to step 608. If the function is not called, the process returns to step 601. In step 608, the function information table 722
The function number CFN is acquired. In step 609,
An entry is created in the call information table 721, the value of the source line number counter SLN is stored in the call source position 7211, and the value of the function number CFN is stored in the function number 7212. Then, the process returns to step 601.

FIG. 8 shows an example of the break point setting command 21. The first command 101 is a normal break point setting command that specifies the line number, and the operand "24" is the line number at which the break point is set. Second command 102
Is a call break point setting command according to the present invention,
The operand "abs" is the function name for which the call break point is set.

FIG. 9 is a flowchart of the processing executed by the command analysis processing 11 and the breakpoint setting processing 12 of the debug processing 1 for the call breakpoint setting command. In step 901, the function name FN is read from the operand of the call interruption point setting command. In step 902,
The function information table 722 is searched to acquire the function number SFI corresponding to the function name FN. In step 903, the search entry number counter FI is set to "0" and initialized. In step 904, the search entry number counter F
Increment I. In step 905, the search entry number counter FI is compared with the total number CNM of entries in the call information table 721. If FI ≦ CNM, the process proceeds to step 906, and if FI> CNM, there are no unexamined entries, and the process ends.

In step 906, a call information table 72 whose entry number is the value of the search entry number counter FI
1 entry is checked, and the function number 7212 of that entry
And the function number SFI are compared. If they do not match, the process returns to step 904. If they match, the process proceeds to step 907. In step 907, the line number CI which is the contents of the calling source position 7211 of the entry is fetched and the line number CI is registered in the interruption point table 3. Then, the process returns to step 904.

FIG. 10 shows an interruption point setting command 10 of FIG.
It is an example of the interruption point table 3 created from 1, 102. Figure 3
Since the source program 4 of 4 is managed only by the line number, the breakpoint table 3 is composed of only the line number 31. The entry 331 corresponds to the first command 101 in FIG. 8 and indicates that the break point is set on the 24th line of the source program 4. Also, entry 332 and entry 3
Reference numeral 33 corresponds to the second command 102 in FIG. 8 and indicates that break points are set on the 15th and 16th lines of the source program 4.

Returning to FIG. 2, the breakpoint setting processing 12 obtains the object position corresponding to the line number registered in the breakpoint table 3 by referring to the row address correspondence table 71 after creating the breakpoint table 3. The instruction at the corresponding position on the object code 6 is saved, and the instruction is replaced with the interrupt instruction. After that, the instruction execution process 13 executes the object code 6. When the break point is reached, the interrupt instruction is executed and an interrupt is generated. Then, the break processing 14 suspends the execution of the object code 6 and waits for an input from the user. At this time, the break point display processing 15 displays the contents of the source program 4 near the break point and highlights the break point with a cursor or the like. When the user instructs continuous execution via the input process 2, the original instruction whose interrupt point has been saved is executed, and then the execution of the object code 6 is restarted from the instruction following the interrupt instruction.

According to the first embodiment described above, the user can set the break points at all the calling points of the function only by specifying the function name, and the debugging work can be performed efficiently. .

Second Embodiment The programming language of the source program 4 in the first embodiment was C language, but the programming language of the source program 4 in the second embodiment is C ++ language. The program execution breakpoint setting method according to the present invention is particularly useful when introduced to a C ++ language that has a wide variety of function types and is capable of implicit function call and dynamic binding. The configuration of the computer that implements the program execution breakpoint setting method of the second embodiment is the same as in FIG. The configuration of the processing group is the same as that in FIG.

FIG. 11 shows an example of the source program 4 for explaining the second embodiment. In order to distinguish from FIG. 3, the line numbers are from 101st line. Programming language is C
It is a ++ language. In the C ++ language, a function has a member function existing inside a class and a non-member function existing outside the class. All the functions in FIG. 11 are member functions.
The non-member function is similar to each function in FIG. Since the member function exists in the class, it is necessary to qualify the class name to identify the function. Therefore, generally, a function is expressed in the form of "class name :: member function name (argument type list)". The argument type list is added because the ambiguity function (functions with the same name but different argument types can be defined) is considered. In FIG. 11, the class List has a constructor List :: List () on line 102, a virtual function List :: print () on line 104, and an operator function List :: operator on line 105.
+ (List) is defined respectively. Also, for the class iList, by specifying ": List" in the latter half of the 108th line,
It inherits all members (including functions) of class List. Further, as a function peculiar to this class iList, a virtual function iList :: print () is defined in the 110th line. In the 110th line, the inherited virtual function List :: print () is added to the class iList.
It was redefined in. The constructor is called automatically when the object is defined.
Then, the function List :: List () is called at the 113th line. The operator function can be called by the operator "+". For example, at line 125, the operator function defined at line 105 is called. A function call that does not take the form of an explicit function call, such as the call of the constructor on the 113th line and the call of the operator function on the 125th line, is an implicit function call.

On the other hand, the virtual functions on the 104th and 110th lines are selected and executed at the time of execution according to the type (= class) of the object by dynamic binding. Lines 122 and 124 are examples of dynamic binding. Lis when the destination pointed to by the variable lp on the 122nd or 124th line is the List type
Call t :: print (), and if it is an iList type, call iList :: print (). Figure 1
In the source program 4 of No. 1, from the situation of the 121th line and the 123rd line, in the 122nd line, List :: print
Call t (), and in line 124, iList :: pr
It can be seen that int () is called, but generally it is unknown which virtual function will be called until run time.

FIG. 12 is a call information table 721 created for the source program 4 of FIG. FIG.
Is a function information table 722 created for the source program 4 of FIG. 11. Unlike the function information table 722 in FIG. 6, the function attribute is stored in the function attribute 7223.
For the sake of distinction from FIG. 6, the function number starts from 4.

FIG. 14 shows an example of the break point setting command. The command 103 is an attribute-designated call interruption point setting command according to the present invention. The attribute condition specification operand “con” has the attribute condition “function attribute is a constructor (c
on) ”is specified. In addition to this, attributes such as an extinction (des), a polysemy operator function (ovp), and a virtual function (vir) can be specified. The function designation operand "List :: List ()" designates a function name. For this command 103, the attribute of the function List :: List () is checked, and only when the attribute is the constructor (con), the call interruption point is set at the call point. The attribute condition specified by the attribute condition specification operand is arbitrary. For example, it is possible to specify a condition that an attribute is a constructor, an extinct child, or a ambiguity operator for a function that can be implicitly called. Further, the function designation operand can be omitted. If omitted, all implicitly callable functions are processed. A dedicated conditional call interruption point setting command equivalent to this may be provided.

The command 104 is a dynamic call interruption point setting command according to the present invention. Although the operand is omitted, the function name can be specified. When the operand is omitted, the break points are set at all the dynamic call points for all the dynamically callable functions (call points at which the call function is not fixed until the execution time). On the other hand, when the function name is specified by the operand, whether the function is a dynamically callable function or not is determined by the function attribute, and only when it is possible, all the dynamic call points for the function are determined. Set a break point at.

FIG. 15 shows a command analysis process 11 of the debug process 1 for the attribute-designated call interruption point setting command.
9 is a flowchart of a process performed by a break point setting process 12. For simplicity of explanation, the function operands are not omitted. When the function operand is omitted, the process becomes the same as the flowchart of FIG. 16 described later.
In step 151, the attribute condition and the function name FN are read from the operand of the attribute designation type call interruption point setting command. In step 152, the function information table 722 is searched,
The function number SFI of the function name FN is acquired. Step 1
In 53, the function information table 722 is searched, the function attribute 7223 of the function name FN is acquired, and it is determined whether or not it matches the condition designated by the attribute condition designation operand.
If they do not match, the process ends without setting a break point. If they match, the process proceeds to step 154.

In step 154, the search entry number counter FI is set to "0" and initialized. Step 1
At 55, the search entry number counter FI is incremented. In step 156, the search entry number counter FI and the total number of entries CNM in the call information table 721 are CNM.
And FI ≦ CNM, the process proceeds to step 157,
If FI> CNM, there are no unexamined entries, and the process ends.

In step 157, the call information table 72 whose entry number is the value of the search entry number counter FI
1 entry is checked, and the function number 7212 of that entry
And the function number SFI are compared. If they do not match, the process returns to step 155. If they match, the process proceeds to step 158. In step 158, the line number CI which is the contents of the calling source position 7211 of the entry is fetched and the line number CI is registered in the interruption point table 3. Then, the process returns to step 155.

FIG. 16 is a flow chart of a process in which the command analysis process 11 and the break point setting process 12 of the debug process 1 set a break point according to a dynamic call break point setting command. In step 161, the function name FN is read from the operand of the dynamic call breakpoint setting command. In step 162, it is determined whether the function name FN has been designated. If the function name FN is specified, the process proceeds to step 163. If the designation of the function name FN is omitted, the process proceeds to step 165.

In step 163, the function information table 722 is searched and the entry FNI of the function name FN is acquired. In step 164, a call interruption point designated by a virtual function is set for the entry FNI in the same manner as in FIG. Then, the process ends.

At step 165, the entry number counter FNI is initialized to "0". In step 166, the entry number counter FNI is incremented. In step 167, the entry number counter FNI is compared with the total number of entries FNM in the function information table 722, and FNI ≦ F
If NM, the process proceeds to step 168. If FNI> FNM, there is no unexamined entry, and the process is terminated. In step 168, a virtual function-specified call interruption point is set for the entry FNI in the same manner as in FIG. And
Return to step 166.

FIG. 17 shows the interruption point setting command 1 of FIG.
It is an example of the interruption point table 3 created from 03,104. Since the source program 4 in FIG. 11 is managed only by the line number, the break point table 3 is composed of only the line number 31. The entry 334 corresponds to the attribute-designated call interruption point setting command 103 in FIG. 14 and indicates that the interruption point is set on the 113th line of the source program 4. Further, the entries 335 and 336 correspond to the dynamic call interruption point setting command 104 of FIG. 14, and indicate that the interruption points are set on the 122nd and 125th lines of the source program 4.

According to the second embodiment described above, the user can set the call interruption point by specifying the function name and the function attribute condition. As a result, it becomes possible to set a fine break point according to the function attribute and set a break point after checking the function attribute. Furthermore, it is possible to effectively confirm the implicit function call point and the function call point by dynamic binding, which contributes to the efficiency of the debugging work.

Third Embodiment In the third embodiment, instead of inputting the break point setting instruction command 21, a break point setting instruction is given by a menu selection method. FIG. 18 is an example of a menu screen. The menu screen includes a source program display screen 181 and a break point setting screen 182. Further, the breakpoint setting screen 182 has function attribute selection menus 1821, class designation selection menus 1822, and function designation selection menus 182 as selection menus for designating the conditions for setting the breakpoints.
3. A function break point selection menu 1824 is provided.

The function attribute selection menu has a selection field 18211, and a condition is specified by clicking the selection field with a pointing device such as a mouse. In the selection field 18211 of the specified condition,
A selection mark is added. The same applies to other selection menus. In the class designation selection menu 1822, since the user has designated “target class designation”, the debug processing 1 displays a list of classes in the source program 4 as a selection submenu 18221. By displaying the selection submenu in this way, it is possible to specify more detailed conditions.

The setting of the break point by the example of the menu screen of FIG. 18 is equivalent to the setting of the break point by the attribute designation type call break point command 103 of FIG.

[0043]

According to the program execution break point setting method of the present invention, the user only needs to input a break point setting command utilizing the executability of the program for a specific processing unit, and one of It becomes possible to set break points for multiple positions. Therefore,
For example, it becomes possible to set break points at a plurality of function call points without burdening the user.

[Brief description of drawings]

FIG. 1 is a configuration diagram of a debugging device that implements a program execution breakpoint setting method of the present invention.

FIG. 2 is a configuration diagram of a processing group related to a program execution breakpoint setting method according to the first embodiment of the present invention.

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

FIG. 4 is an exemplary diagram of a row address correspondence table.

FIG. 5 is a view showing an example of a call information table.

FIG. 6 is a view showing an example of a function information table.

FIG. 7 is a flowchart showing a procedure for creating function call information.

FIG. 8 is a view showing an example of a break point setting command.

FIG. 9 is a flowchart showing a processing procedure for a call interruption point setting command.

FIG. 10 is an exemplary diagram of a break point table.

FIG. 11 is another exemplary diagram of a source program.

FIG. 12 is another exemplary diagram of a call information table.

FIG. 13 is another exemplary diagram of a function information table.

FIG. 14 is another exemplary diagram of a breakpoint setting command.

FIG. 15 is a flowchart showing a processing procedure for an attribute designation type call interruption point setting command.

FIG. 16 is a flowchart showing a processing procedure for a dynamic call interruption point setting command.

FIG. 17 is another exemplary diagram of a break point table.

FIG. 18 is a view showing an example of a menu screen.

[Explanation of symbols]

1000 Debugging device 1001
Memory 1002 Display device 1003
CPU 1004 Input device 1005
External storage device 1 Debugging process 2 Input process 3 Break point table 4 Source program 5 Compile process 7 Source information file 11 Command analysis process 12 Break point setting means 15 Break point display process

Claims (13)

[Claims] 1. A feasibility information extraction step of analyzing a program to extract feasibility information for a specific processing unit of the program, and an interruption point setting command utilizing the feasibility of the program for a specific processing unit. A step of receiving a break point setting instruction, and a step of setting a break point at one or more positions associated with the program based on the feasibility information and the break point setting instruction. What is characterized is a method for setting a program execution break point. 2. The program execution breakpoint setting method according to claim 1, wherein the specific processing unit of the program is a function call, and the feasibility information extracting step executes position information of a function call point in the program. A program execution break point setting method characterized by extracting as possibility information. 3. The program execution breakpoint setting method according to claim 2, wherein when a function can be called implicitly to call the function in the form of variable declaration or operation, the function calling point A program execution break point setting method characterized in that position information is also extracted as executability information. 4. The program execution breakpoint setting method according to claim 2 or 3, wherein when a function to be called can be dynamically called in which a function to be called at execution is determined as a function calling form, the function is called by dynamic calling. A program execution interruption point setting method characterized in that position information of points is also extracted as executability information. 5. The program execution break point setting method according to claim 2, wherein a call break point setting instruction for specifying a function and setting break points at all function call points for the function. When the interruption point setting command acceptance step is received, the interruption point setting step sets the interruption points at the positions of all the function call points in the program for the specified function. Method. 6. The program execution break point setting method according to claim 2, wherein a call break point setting instruction for setting a break point to all function call points without specifying a function is interrupted. A program execution breakpoint setting method characterized in that, when the point setting command receiving step receives, the breakpoint setting step sets breakpoints at positions of all function calling points for all functions in the program. 7. The program execution break point setting method according to claim 1, wherein the specific processing unit of the program is a function call, and the feasibility information extracting step includes position information and a function of a function call point in the program. A method for setting a program execution break point, characterized in that function attribute information that defines the nature of a method of calling a function, the type of function, etc. is extracted as executability information. 8. The program execution break point setting method according to claim 7, wherein when a function is called by an implicit call for calling a function in the form of variable declaration or operation, the function call point by the implicit call is set. A program execution break point setting method characterized in that position information is also extracted as executability information. 9. The program execution breakpoint setting method according to claim 7 or 8, wherein when the function to be called can be dynamically called by determining a function to be called at the time of execution, the function is called by the dynamic call. A program execution interruption point setting method characterized in that position information of points is also extracted as executability information. 10. The program execution breakpoint setting method according to claim 7, wherein a function and a function attribute condition are specified and breakpoints are set at all function call points satisfying the function attribute condition. When the interruption point setting instruction reception step receives the conditional call interruption point setting instruction to be set, the interruption point setting step determines whether the specified function satisfies the specified function attribute condition, and only when the condition is satisfied, A program execution breakpoint setting method, wherein breakpoints are set at positions of all function call points in a program for the specified function. 11. The program execution breakpoint setting method according to any one of claims 7 to 10, wherein function specification is omitted, function attribute conditions are specified, and all function calls satisfying the function attribute conditions are specified. Conditional call for setting a break point at a point When the break point setting command reception step receives a break point setting command, the break point setting step satisfies the specified function attribute condition for all functions in the program. A program execution break point setting method characterized in that the break points are set at the positions of all the function call points in the program for the function only when it is judged and satisfied. 12. The program execution breakpoint setting method according to claim 10 or 11, wherein when the function can be called implicitly by calling the function in the form of variable declaration or operation, the implicit call is made. A method for setting a program execution break point, wherein a function attribute condition can be specified so as to include it. 13. The program execution interruption point setting method according to claim 10, wherein a dynamic call is made when a function to be called at the time of execution can be determined dynamically as a function call form. A method for setting a program execution break point, wherein a function attribute condition can be specified such that