JPH03161843A - debug equipment - Google Patents

Abstract

(57) [Summary] This bulletin contains application data before electronic filing, so abstract data is not recorded.

Description

[Detailed Description of the Invention] [Summary] Regarding a debugging method in which a variable is accessed at the interruption point of a program that is called from a program to which a variable is allocated to a register, a variable allocated to a register,
The start position, end position, and register number of this variable are saved as register allocation information in advance, and the contents of the save area are accessed by referring to this register allocation information at the interrupt point of the called program during debugging. Alternatively, the contents of the corresponding register are updated upon return, and the purpose is to enable debugging in the high-level language view for the called program at the module level, which has been allocated registers through optimization. Create and save the variables, start position, end position, and register number as register allocation information in advance, and refer to this register allocation information at the interrupt point in the program called from a certain program during debugging and try to access it. When a variable is allocated to a register at the branch position of the calling program and is within the range of the start and end positions, the register number is retrieved and the area where the contents of this register number are saved is accessed, or the variable is updated. Take care to remember the value and update the contents of the corresponding register number when returning to the calling program.

[Industrial application field]

The present invention relates to a debugging method in which a variable is accessed at the interrupted position of a program that is called from a program to which the variable has been allocated to registers.

[Prior art and the problem to be solved by the invention] Conventionally, for a variable allocated to a register by optimization during translation of a source program, this variable is allocated at the interrupt point of the program called from the program in which this variable is declared. When debugging by referencing/updating the value of , it was done in the machine language view (load module level).

For this reason, there is a problem in that debugging cannot be performed using a high-level language view in which the source program is written, making debugging difficult.

The present invention saves a variable allocated to a register, the start position and end position of this variable, and the register number as register allocation information in advance, and assigns this register allocation at the interruption point of the called program during debugging. Access the contents of the save area by referring to the information, or update the contents of the corresponding register when returning, and enable debugging in the high-level language view for the called program at the load module level that has been allocated registers through optimization. It is an object.

[Means to solve problems]

Means for solving the problem will be explained with reference to FIG.

In FIG. 1, program 1 is a caller load module level program.

Program 2 is a load module level program called from program 1.

The register save area 3 is an area where the contents of the registers of the program 1 are saved.

The register allocation information 4 includes variables allocated to registers through optimization, the start position and end position of these variables, and register numbers, which are created and saved in advance.

[Effect]

As shown in FIG. 1, the present invention refers to the register allocation information 4 at the interruption position of the program 2 called from the program 1 during debugging, and the variable to be accessed is registered at the branch position of the calling program 1. When the register number is allocated and is within the range of the start position and end position, the register number is extracted and the contents of this register number are saved to register save area 3, which is accessed, or the updated value of the variable is saved and the calling program When the register number returns to 1, the contents of the register number are updated.

Therefore, the variable allocated to the register, the start position and end position of this variable, and the register number should be saved in advance as register allocation information 4, and this register allocation will be made at the interruption position of the called program 2 during debugging. By accessing the contents of the save area by referring to information 4 or updating the contents of the corresponding register at the time of return, debugging the called program 2 at the load module level, which has been allocated registers through optimization, in the high-level language view. becomes possible.

〔Example〕

Next, the structure and operation of the first embodiment of the present invention will be explained in detail using FIGS. 1 to 3.

In Figure 1 (a), program 1 is a caller load module level program.Here, variable 1 is defined by INTEGER I, and CAL
L Program 2 is called by Program 2. The offset address from the beginning of the section on the load module where this CALL program 2 is located is the branch position, and is recorded at the time of branching.

Program 2 is a load module level program called from program 1.

When this program 2 is called, program l
The value (content) stored in the register used by is saved in the register save area 3 as shown in the figure. Then, control is transferred to the debugger by the debugger call instruction embedded in advance at the interrupted position shown in the diagram, and the debugger is activated as shown in FIG.
The value of the variable is accessed by referring to the register allocation information 4.

FIG. 1 (opening) shows register allocation information.

Here, the start position information is the start position of the range where the variable is allocated to registers (line number of the source program, offset 7} address from the beginning of the section of the load module)
It is. The end position information is the end position of the range where the variable is allocated to registers (line number of the source program, offset address from the beginning of the load module section)
It is. Variable information includes variable names assigned to registers,
Attributes, etc. The register information includes the register number and type assigned to the variable. In reality, the start position information, end position information, and variable information do not have these information directly, but they are collected in one place and pointed to with a pointer so that they can be used from other places as well. The area size is reduced.

Next, the operation of the first diagram will be explained in detail in accordance with the order shown in FIGS. 2 and 3.

In FIG. 2, ■ starts the debugger.

(2) Instructs to set the interruption position. This is shown in Figure 1 (a) from the screen displayed by Devasoga started in ■.
Specify the interruption position ■.

0 indicates the start of program execution. Here, the first
Figure (a) An instruction to start execution is given from the beginning of program 1.

[Phase] starts execution of program 1.

(2) determines whether program 2 is to be called or not. This is executed sequentially from the beginning of program 1 in Figure 1 (a).
CALL Determine whether program 2 has been called by program 2. If YES, [phase]
Do the following. In the case of No, repeat ①.

[Phase] records the offset address of the branch position.

This is, for example, the off-cent address of the illustrated branch position where program 2 was called, as shown in FIG.
Record 100”.

Otherwise, program 2 is executed as [phase] or [phase].

[Phase] saves the contents of the register. This is the first
Figure (a) In register saving at the beginning of program 2, the contents of the registers used in program l are saved to register saving area 3.

[Phase] executes the command.

q [Phase] determines whether or not it is an interruption position. If YES, press ■ to transfer control to the debugger and perform debugger processing (
Figure 3). If No, repeat [phase].

Next, the processing of the debanger that receives control at the interruption position will be explained.

In FIG. 3, [phase] instructs to display the value of a variable. The debugger receives control at the interruption point and displays a screen, from which the user instructs the display of variable values. For example, it instructs to display the value of the variable (■) declared in program 1.

O determines whether the program in which the variable was declared and the currently suspended program are the same. In the case of YES, since the value of the variable has not been saved in the register, the area/register allocated to the variable is referred to in (■) and its contents are displayed. If No, perform ■.

(2) determines whether a variable is allocated to a register at the branch position. This is done by referring to the register allocation information 4 to determine whether or not the offset address of the branch position recorded in FIG. Here, for example, the variable I declared in Figure 1 (A) Program 1 is at the branch point ig
oo, refer to the register allocation information 4 in Figure 1 (opening) and change the offset address "050" to "1" as shown in ■.
Since it is within the range of 10'', the answer is YES and step (2) is executed. On the other hand, if the answer is No, the variable is not allocated to a register, so step (2) is executed.

[Phase] examines the register number. This is for example the case in Figure 1 of variable 1, which was found to be register-allocated with @ (
口) Take out the register number "l" of ■.

[Phase] obtains the register contents from the save area. this is,
FIG. 1(A) The contents of the saved register are retrieved from the area corresponding to the register number in the register save area 3.

[Phase] displays its contents.

With the above processing, for example, when attempting to refer to the value of variable 1 at the interruption position of program 21l called from program l in which variable 1 was declared, register allocation information 4 in Figure 1 (b) can be used. It is possible to find out the register number assigned to the variable I at the branch position of program 1 by referring to it, and to retrieve and display the contents of this register number from the register save area 3 where the contents of this register number are saved. .

In addition, if a variable update instruction is given at the interruption point of the called program 2, save the information that the save area for the corresponding register number will be changed and the value to be changed, and save it when returning to the original program 1. The stored value is retrieved and updated by setting it in the corresponding register, and the contents of the area allocated to the variable are updated as necessary.

〔Effect of the invention〕

As explained above, according to the present invention, a variable allocated to a register, the start position, end position of this variable, and register number are stored in advance as register allocation information 4, and at the time of debugging 12. A structure is adopted in which the contents of the register save area 3 are accessed by referring to this register allocation information Ig4 at the interruption point of the program 2 called from the program 1 where the variable was declared, or the contents of the corresponding register/area are updated when returning. Therefore, it is possible to perform dehasing in a high-level language view on a load module-level program that has been allocated registers through optimization.

[Brief explanation of the drawing]

FIG. 1 is a schematic diagram of one embodiment of the present invention, FIG. 2 is a flowchart explaining the operation of the present invention - 1., and FIG. 3 is a debugger processing flowchart of FIG. 2 (2). In the figure, program 1 is the calling program, program 2 is the destination program 17T, 3 is a register save area, and 4 is register allocation information. Patent source Fujitsu Limited

Claims (1)

[Scope of Claims] In a debugging method in which a variable is accessed at the interruption point of a program called from a program to which the variable has been allocated to a register, the variable, start position, end position, and register number allocated to registers through optimization. Register allocation information (4)
This register allocation information (4) is referenced at the interrupt point in the program called from a certain program during debugging, and the variable to be accessed is registered at the branch point of the calling program. Extract the register number when it is allocated and within the range of the start and end positions, and access the area where the contents of this register number are saved, or store the updated value of the variable and return to the calling program. An optimized code debugging method characterized in that the content of the corresponding register number is updated when the code is updated.