JPH03273346A - Dynamic call relation analyzing system by symbolic debugger - Google Patents

Abstract

PURPOSE:To take out call relation at an arbitrary time point with the small amount of information by integrating a stack analysis part, call relation analysis part, table processing part, table output part and table into a symbolic debugger. CONSTITUTION:The call relation analysis part 9 takes out the call relation between sub routines, which is observed from the sub routine generating interruption, from the stack analysis part 8. Next, the call relation is simplified by adding any special mark to the sub routine under retroactive calling. Afterwards, when the call relation is already registered to the call relation table 12, control is returned to a command execution part 4. According to an instruction from the execution part 4, the call relation table output part 11 outputs the call relation between the sub routines from an executed result output part 5 while referring to the table 12. Thus, the call relation between the sub routines is dynamically analyzed and taken out at the arbitrary time point with the small amount of information.

Description

Detailed Description of the Invention [Field of Industrial Application] The present invention relates to a symbolic debugger used for debugging a program at the source level in an information processing system, and in particular to a symbolic debugger used for debugging a program at the source level in an information processing system. We will use a dynamic call relationship analysis method using a sympolink debuffer that dynamically analyzes the call relationship between subroutines in situations where the call relationship between subroutines changes.

[Conventional technology]

Conventionally, the calling relationships between subroutines in a user program were often known to the user who created the user program, and therefore were rarely handled in the field of debugging. However, as user programs become larger in size, the number of subroutines increases, making it difficult for users to understand the calling relationships between subroutines.

Conventionally, a method for solving such problems has been based on static analysis of programs. One method is to display the calling relationships between subroutines by inputting all source programs constituting the program and analyzing subroutine calling instructions (CALL instructions).

Another method is to display the calling relationships between subroutines by inputting and linking all object programs that make up the program.

On the other hand, there is also a dynamic tracing method in which a debugger dynamically sets a breakpoint at the beginning of each subroutine in the program and displays the subroutine name each time control reaches the breakpoint.

[Problem to be solved by the invention]

The conventional call relationship analysis method described above displays the call relationships between subroutines by inputting the source program and analyzing the subroutine call instructions, but it is only possible to analyze the static call relationships of the program. This method has the disadvantage that it is not possible to analyze dynamic calling relationships between subroutines in which the called subroutines are changed depending on input data.

In addition, the method of displaying the calling relationships between subroutines by inputting and linking an object program allows you to analyze the static calling relationships of a program in the same way as when analyzing subroutine calling instructions in a source program. This method has the disadvantage that it is not possible to dynamically analyze call relationships between subroutines in which the called subroutines are changed depending on program input data.

On the other hand, in a dynamic tracing method in which a breakpoint is dynamically set at the beginning of each subroutine in the program using a debuffer and the subroutine name is displayed each time control reaches the breakpoint, subroutines are recursively (υ If the subroutine is called by a subroutine, all of the subroutines that are called many times will be traced, so the amount of information displayed for the subroutine name will be large, making it difficult to use, and checking the calling relationships between subroutines. The drawback is that it lacks functionality.

In view of the above-mentioned points, an object of the present invention is to dynamically analyze the calling relationships between subroutines in a program, and to enable a user to know the calling relationships between subroutines at any time and with a small amount of information. The purpose of this invention is to provide a dynamic call relationship analysis method using a simple Fuku debanger.

[Means to solve the problem]

The dynamic call relationship analysis method using the sympolink debuffer of the present invention consists of a command input section for inputting commands for debugging, a command execution section for processing commands input by this command input section, and a command execution section for processing commands input by this command input section. a symbol information conversion unit that mutually converts symbol information and a memory address of the program according to instructions from the command execution unit; an interrupt processing unit that sets breakpoints in the program according to instructions from the command execution unit; and execution results by the command execution unit. Equipped with an execution result output section that outputs
In Simpoly Fuku Debugger, which enables debugging of programs at the source level, this is an interrupt that occurs at a breakpoint that is set for the purpose of collecting information about calls between subroutines when an interrupt occurs in a program. The command execution unit determines whether the interrupt is a Based on the address where the interrupt occurred, check the subroutine name of the subroutine whose processing has stopped, extract the return address from the stack of the subroutine, recognize the calling subroutine name, and repeat this process until there are no more calling subroutines. a stack analysis unit that extracts the calling relationship between subroutines as seen from the subroutine in which the error occurred, and a call relationship analysis unit that simplifies the calling relationship between the subroutines extracted by the stack analysis unit for subroutines that are recursively called. , a call relationship table processing unit that registers the call relationship between subroutines simplified by the call relationship analysis unit in a call relationship table; and a call relationship table processing unit that refers to the call relationship table according to instructions from the command execution unit and processes calls between subroutines. and a call relationship table output section for outputting the relationship information by the execution result output section.

[Effect]

In the dynamic call relationship analysis method using the sympolink debuffer of the present invention, the command execution section uses interrupts that occur at breakpoints that are set for the purpose of collecting information about call relationships between subroutines when an interrupt occurs in a program. If the stack analysis unit determines that the interrupt occurred at a breakpoint set by the command execution unit for the purpose of collecting information about calls between subroutines, the symbol information conversion unit Based on the address where the interrupt occurred, check the subroutine name of the subroutine whose processing has stopped, extract the return address from the stack of the subroutine, recognize the calling subroutine name, and repeat this process until there are no more calling subroutines. The calling relationship between subroutines as seen from the subroutine where the error occurred is extracted, and the calling relationship analysis unit simplifies the calling relationship between the subroutines extracted by the stack analysis unit for subroutines that are recursively called, and the calling relationship table processing unit The call relationship analysis unit registers the simplified call relationships between subroutines in the call relationship table, and the call relationship table output unit refers to the call relationship table according to instructions from the command execution unit and executes the call relationships between subroutines. Output by the result output section.

〔Example〕

Next, the present invention will be explained in detail with reference to the drawings.

A first FjJ is a block diagram showing the configuration of a sympolink debuffer 1 to which a dynamic call relationship analysis method according to an embodiment of the present invention is applied. This symbolic devasoga 1 includes a main control section 2, a command input section 3, a command execution section 4, an execution result output section 5, a symbol information conversion section 6,
It is configured to include an interrupt processing section 7, a stack analysis section 8, a call relation analysis section 9, a call relation table processing section 10, a call relation table output section 11, and a call relation table 12. In addition, the code 13 is a terminal device, 1
4 is a system input file (hereinafter abbreviated as 5YsIN file), 15 is a system output file (hereinafter referred to as 5YsIN file).
(abbreviated as YSOUT file) and 16 each indicate a user program including a plurality of subroutines.

Next, the operation of the dynamic call relationship analysis method using the sympolink devasoga of this embodiment configured as described above will be explained.

When the Simpoly Fuku debanger 1 is started according to the user's specifications, the main control unit 2 operates first, and the user program 1
6 into memory (not shown). When the loading of the user program 16 is completed, the main control section 2 passes control to the command input section 3.

The command input unit 3 inputs commands for debugging from the terminal bag 213 or the 5YSIN file 14 and passes them to the main control unit 2.

The main control section 2 passes the command received from the command input section 3 to the command execution section 4.

If the command passed from the main control unit 2 instructs the setting of a breakpoint, the command execution unit 4 uses the symbol information conversion unit 6 to convert symbol information such as line numbers into the user program. 16 memory address, and uses the interrupt processing unit 7 to execute the user program 1.
Set a breakpoint at 6.

In addition, if the command passed from the main control unit 2 is an instruction to refer to the contents of a variable held by the user program 16, the command execution unit 4 uses the symbol information conversion unit 6 to convert the variable After converting the symbol information such as name into the memo IJA1 of the user program I6 and accessing the memory of the user program 16 to extract and edit the contents of the variables, the execution result output unit 5 outputs the terminal device 13 or 5ySOUT. The contents of the variables are output to the file 15.

Furthermore, if the command passed from the main control unit 2 is an instruction to execute the user program 16, the command execution unit 4 uses the interrupt processing unit 7 to operate the user program 16. .

When the user program 16 is executed and reaches a breakpoint set in advance, an interrupt occurs in the user program 16 and control is transferred to the interrupt processing section 7.

The interrupt processing unit 7 notifies the command execution unit 4 that the breakpoint has been reached.

The command execution unit 4 outputs a command input prompting message for debugging to the terminal device 13 or the 5YSOUT file 15 through the execution result output unit 5, and waits for command input.

When a command instructing the collection of information related to calls between subroutines is input from the terminal device 13 or the 5YSIN file 14, the main control unit 2 receives the command via the command input unit 3 and executes the command execution unit 4. give it to

When the command execution unit 4 receives a command 'instructing to collect information on call relationships between subroutines from the main control unit 2, it uses the symbol information conversion unit 6 to convert all subroutines in the user program 16. The subroutine name is converted into a memory address of the user program 16 as symbol information, and break points are set at the beginnings of all subroutines included in the user program 16 using the interrupt processing unit 7.

Thereafter, when a command instructing the operation of the user program 16 is input from the terminal device 13, the command execution unit 4
Then, the operation of the user program 16 is restarted via the interrupt processing section 7. When an interrupt occurs at the beginning of the subroutine, control is transferred from the user program 16 to the interrupt processing section 7.

The interrupt processing unit 7 notifies the command execution unit 4 that the breakpoint has been reached.

The command execution unit 4 receives the notification from the interrupt processing unit 7, recognizes that an interrupt has occurred at a breakpoint for collecting information on call relationships between subroutines based on the address where the interrupt has occurred, and performs stack analysis. Control is passed to section 8.

The stack analysis unit 8 uses the symbol information conversion unit 6 to extract the subroutine name of the subroutine in which the processing of the user program 16 has stopped from the symbol information existing in the user program 16 based on the address where the interrupt occurred. Then, the stack analyzer 8 extracts the return address from the stack of the subroutine in which the interrupt occurred in the user program 16 as the address of the subroutine that called the subroutine in which the interrupt occurred, and uses the symbol information converter 6 to extract the return address from the stack of the subroutine that called the subroutine in which the interrupt occurred. Convert subroutine name to subroutine name. The stack analysis unit 8 repeats the above process, sequentially obtains the calling subroutine name from the return address in the stack of the called subroutine, and extracts the calling relationship between the subroutines from the perspective of the subroutine in which the interrupt has occurred. , when the calling subroutine disappears, the stack analysis section 8 passes control to the call relationship analysis section 9.

The call relationship analysis unit 9 receives as a parameter the call relationship between subroutines as seen from the subroutine in which the interrupt has occurred from the stack analysis unit 8, and first checks whether there is a subroutine that is called recursively. If there is a subroutine that is called recursively, the call relationship analysis unit 9 adds a special mark to the subroutine that is called recursively and simplifies the call relationship between the subroutines. The calling relationship table 12 is referred to to check whether the calling relationship between the subroutines currently being processed has already been registered in the calling relationship table 12. If the calling relationship between the subroutines currently being processed has already been registered in the calling relationship table 12, the calling relationship analysis unit 9 returns control to the command execution unit 4. If it is not registered in the call relationship table 12, the call relationship analysis unit 9 transfers control to the call relationship table processing unit 10.

The call relationship table processing unit 10 registers call relationships between subroutines in the call relationship table 12 and returns control to the command execution unit 4.

In addition, if the command passed from the main control unit 2 is an instruction to display the calling relationship between subroutines, the command execution unit 4 outputs a call relationship table output unit 11.
transfer control to

A call relationship table output unit 11 extracts and edits the call relationships between subroutines from a call relationship table 12, and outputs the results to the terminal device 13 or 5YSU by the execution result output unit 5.
Output to OUT file 15. At this time, the call relationship table output unit 11 adds a special mark to the list for subroutines that are recursively called. Thereafter, the call relationship table output unit 11 returns control to the command execution unit 4.

Next, referring to FIG. 2+al to fd), stack analysis unit 8. The processing of the call relationship analysis section 9 and the call relationship table processing section 10 will be explained in more detail.

The stack analysis unit 8 analyzes the subroutine X in which the interrupt occurred.
The subroutines that called the subroutines are traced in the order in which they were called, and the calling relationship between the subroutines shown in FIG. 2 fat is extracted.

Next, the call relationship analysis unit 9 inputs the call relationship between the subroutines shown in FIG. , the calling relationship between the subroutines as shown in FIG. Check whether the calling relationships between subroutines already registered in the calling relationship table 12 as shown in C) can be registered, and check the calling relationships below subroutine Z in FIG. 2('b). FIG. 2 (It is decided to register below subroutine G of C1.

Subsequently, the call relation table processing unit 1o (see Figure 2)
The calling relationship below subroutine Z is shown in Figure 2 (C
It is registered below subroutine G of 1. As a result, the contents of the calling relationship table 12 become the calling relationships between subroutines as shown in FIG. 2 fd+.

〔Effect of the invention〕

As explained above, the present invention incorporates a stack analysis section, a call relation analysis section, a call relation table processing section, a call relation table cutting section, and a call relation table into a sympolink debuffer, thereby allowing the user to perform subroutines. This has the effect of making it possible to dynamically retrieve information on the call relationships between them at any time.

Another advantage is that it becomes possible to dynamically examine the calling relationships between subroutines while changing the values of data processed by the program.

Furthermore, for subroutines that are called recursively, the calling relationship between subroutines can be simplified and the amount of information can be retrieved with a small amount.

The above has the effect of dramatically improving the efficiency of program debugging work.

[Brief explanation of drawings]

FIG. 1 is a block diagram showing the configuration of Simpoly Fuku Devasoga to which the dynamic call relationship analysis method according to an embodiment of the present invention is applied; It is a diagram for explaining the processing of the call relationship analysis unit, the call relationship analysis unit, and the call relationship table processing unit. , 4... Command execution section, 5... Execution result output section, 6... Symbol information conversion section, 7... Interrupt processing section, 8... Stack analysis section, 9.. . 10. 11. l2, 13, 14, l5, l6 - Calling relationship analysis unit, calling relationship table processing unit, calling relationship table output unit, calling relationship table, terminal device, SYS IN file, 5YSOUT file, user program.

Claims (1)

[Scope of Claims] A command input section for inputting commands for debugging, a command execution section for processing commands input by the command input section, and a memory for storing symbol information and programs according to instructions from the command execution section. a symbol information conversion unit that converts the addresses and the like; an interrupt processing unit that sets breakpoints in the program according to instructions from the command execution unit; and an execution result output unit that outputs the results of execution by the command execution unit. , in a symbolic debugger that enables debugging of programs at the source level, when an interrupt occurs in a program, it is possible to check whether the interrupt occurred at a breakpoint set for the purpose of collecting information on call relationships between subroutines. The command execution unit makes the determination, and the symbol information conversion unit handles the interrupt when it is determined by the command execution unit that the interrupt has occurred at a breakpoint set for the purpose of collecting information on call relationships between subroutines. An interrupt is generated by checking the subroutine name of the subroutine whose processing has stopped based on the generated address, extracting the return address from the stack of the relevant subroutine, recognizing the calling subroutine name, and repeating this process until there are no more calling subroutines. a stack analysis section that extracts calling relationships between subroutines as seen from the subroutines that are called; a call relationship analysis section that simplifies the calling relationships between subroutines extracted by this stack analysis section for subroutines that are recursively called; a call relationship table processing unit that registers the call relationship between subroutines simplified by the call relationship analysis unit in a call relationship table; and a call relationship table processing unit that refers to the call relationship table according to instructions from the command execution unit to determine the call relationship between subroutines. A dynamic call relationship analysis method using a symbolic debugger, comprising: a call relationship table output unit outputted by the execution result output unit.