JPH01177644A - Debugging device - Google Patents

Abstract

PURPOSE:To make high-speed access by providing a means to trace an executive stack in a real device in a debugging device. CONSTITUTION:The return address of a subroutine stored in a point where an offset value is separated from a variable A to exist in a memory 14, and it is set to a variable B to exist in the memory 14. Next, the contents of the variable B, namely, the return address is contained in a register 17. Whether the address exists between the starting address of the designated subroutine and the completing address of the subroutine contained in a register 18 or not is decided. Namely, when it exists between them, the subroutine to call the subroutine, to which an attention is paid, is the designated subroutine, and when it does not exist between them, the frame pointer of the subroutine to call the subroutine stored into a point where the offset value is separated from the frame pointer is obtained, and it is set to the variable A. Thus, the access to the real argument of the subroutine of a program or a local variable can be made high-speed, and the efficiency of a debugging work can be improved.

Description

DETAILED DESCRIPTION OF THE INVENTION The present invention relates to a debugging device, and more particularly, to a debugging device characterized by high-speed access to actual arguments or local variables of a subroutine of a program.

(Prior Art) Conventionally, in a debugging device connected to an actual device for debugging, a program memory address in the actual device to be accessed is specified, and data is written to or read from the address. Data was being read.

(Problem to be Solved by the Invention) In the conventional method described above, for example, in a program written in a high-level language, when a subroutine is called during program execution, actual arguments, local variables, and the caller are stored on the runtime stack. A stack frame is formed consisting of the frame pointer value pointing to the frame of the subroutine and the return address. At this time, the following problem occurs when accessing the memory address corresponding to the actual argument or local variable of the specified subroutine.

First, the contents of the stack frame are examined by following the frame pointer in the stack frame from the stack frame of the most recently called subroutine in the runtime stack to the stack frame of the calling subroutine.

If the return address in the stack frame is included in the instruction area of the specified subroutine, the subroutine that called the subroutine corresponding to the stack frame
You can see that it is the specified subroutine. Therefore, the actual arguments and local variables held in the stack frame of the subroutine are accessed.

At this time, when the host machine that holds the program source files and symbol table is connected to the debugging device via a line, and the host machine attempts to access the actual arguments and local variables of the specified function, the command of the function Because only the host machine has information about the area, the actual argument to be accessed, and the relative position within the frame of local variables, communication between the host machine and the debugging device is difficult when traversing the execution stack, as described above. The number of times this happens increases, and the actual arguments of the subroutine or local variables cannot be accessed quickly, leading to a decrease in the efficiency of debugging work.

The present invention solves these conventional drawbacks, and its purpose is to increase the efficiency of debugging work by speeding up access to actual arguments or local variables of program subroutines.

(Means for Solving the Problem) The present invention provides a debugging device that includes a first register that holds a subroutine start address of a program being executed on the actual machine, and a second register that holds the subroutine end address of the program that is being executed on the actual machine.
registers and arguments of subroutines executed in the actual machine,
Or a third register that holds the offset from the frame pointer of the area where local variables are stored, a fourth register that holds the data read from the area, or data written to the area, and the program memory in the actual machine. Find the frame of the subroutine corresponding to the first register and the second register from the execution stack of the subroutine in the subroutine, and from the frame, the actual argument of the subroutine specified by the offset value stored in the third register,
Alternatively, it has means for reading the contents of the address of the local variable and setting it in the fourth register, and means for writing the contents of the fourth register at the address.

(Example) Next, embodiments of the present invention will be described with reference to the drawings.

FIG. 1 is a block diagram of an embodiment of the debugging device of the present invention, which is composed of a debugging device 1 and an actual device 2. As shown in FIG.

The debug device 1 includes a processor 10, a memory 14, a display 15, a keyboard 16, a control circuit 103 that controls the processor 20 of the actual machine, a register 17 that stores the start address of a specified subroutine, and an end address of the specified subroutine. Register 18, a register 19 that stores the offset value from the frame pointer to a local variable accessed in a specified subroutine or an actual argument; It includes a data register 101 that stores data read from an argument, and an access register 102 that holds a read or write access method.

Processor 10, memory 14, dayplay 15, keyboard 16, register 17, register 18, register 19
, data register 101 are connected by a data bus 11, an address bus 12, and a control bus 13. The actual machine 2 includes a processor 6 = processor 20 and a memory 24. -address bus 22
, the processor 20 and the memory 24 are connected by a data bus 21 and a control bus 23. In the memory 14 of the debugging device 1, a display 15 and a keyboard 16 are controlled to set the instruction start address of a specified subroutine in a register 17, set the instruction end address of the subroutine in a register 18, and access the subroutine. Set the offset value from the frame pointer of the local variable or actual argument in the register 19, set the read or write access method to the local variable or actual argument in the instruction register 102, and set it in the local variable or actual argument. The program includes a program that sets data to the data register 101 or reads data from the data register 101 holding data read from the local variable or actual argument.

Next, the operation of the debugging device shown in FIG. 1 will be explained using FIGS. 2 and 3.

First, in the debugging device 1, the program included in the memory 14 is activated. The program receives input from the keyboard 16 of the instruction start address of the subroutine to be accessed, the instruction end address, the local variable to be accessed, or the offset value from the frame pointer of the actual argument, and registers 17, 18, and 19, respectively.
Furthermore, the access method is set in the command register 102, and if the contents of the command register 102 are a write command, write data is set in the data register 101.

Next, while the execution of the actual device 2 is suspended, the control program included in the memory 14 performs the processing shown in FIG. That is, the control program sets the contents of the frame pointer register of the processor 20 (FIG. 3) to the variable A in the memory 14 (FIG. 2 201).

Next, in the stack frame of the subroutine, find the return address of the subroutine that is stored at an offset value away from variable A, and
(202 in FIG. 2).

Next, the contents of variable B, ie, the return address, are included in register 17. It is determined whether the start address of the specified subroutine is between the end address of the subroutine contained in register 18 (Fig. 2, 203). If there is time, the subroutine that called the subroutine of interest is , is the specified subroutine.

If the return address of the subroutine is not between registers 17 and 18, the subroutine that called the subroutine of interest is not the specified subroutine.

Therefore, find the frame pointer of the subroutine that called the subroutine, which is stored at a location that is an offset value away from the frame pointer, and set it in variable A (second
Figure 205).

The return address of the subroutine described above is determined.

In determining the return address of the subroutine 203,
When the specified subroutine is found, the pointer value of the stack frame of the specified subroutine is set in variable A (FIG. 2, 204).

Next, in 206 of FIG. 2, the contents of the instruction register 102 are checked, and in the case of a write instruction, the contents of the data register 101 are written to a memory address separated by an offset value included in the register 19 from the contents of fluctuation A (second Figure 20
7〉.

Further, in the case of a read instruction, the contents of the address are set in the data register 101. With this, the operation of the control program included in the memory 14 ends (208 in FIG. 2).

- (Effects of the Invention) As explained above, the present invention provides a method for accessing local variables or actual arguments of subroutines that become the runtime stack that is formed when a program written in a high-level language or the like is executed on an actual machine. By providing the debug device with means for tracing the executable stack in the actual machine, it becomes possible to access the memory at a higher speed than in a debug device that only allows memory access using addresses. Furthermore, when backing up data by connecting a debug device and a host machine via a line, it is possible to reduce the amount of communication between the host machine and the debug device, improving debugging effectiveness compared to conventional debug devices. It has the effect of causing

BRIEF DESCRIPTION OF THE DRAWINGS FIG. 1 is a block diagram showing an embodiment of the present invention, FIG. 2 is a flowchart showing an example of the process of accessing local variables or actual arguments of a subroutine in the execution stack on an actual machine, and FIG. FIG. 3 is a diagram showing an example of an execution stack in an actual machine for explaining FIG. 2;

1...Debug device 10...Data bus 11...
・Address bus 12...Control bus 14...
・Memory 15... Display 16... Keyboard 17... Register 18... Register 19... Register 101... Data register 102... Access register

Claims (1)

[Claims] A debugging device that performs program debugging by extracting address signals, data signals, and control signals from a system bus or a terminal of the processor of an actual machine that is equipped with a processor and a program memory in which a control program for the processor is recorded. A first register holds the subroutine start address of the program being executed in , and a second register holds the end address of the subroutine.
and a third register that holds the offset from the frame pointer of the area where the arguments or local variables of the subroutine executed in the actual machine are stored, and the data read from or written to the area. Find the frame of the subroutine corresponding to the first register and the second register from the execution stack of the subroutine in the fourth register and the program memory of the actual machine, and calculate the offset value stored in the third register from the frame. means for reading out the contents of an actual argument of a subroutine or the address of a local variable specified by and setting it in a fourth register, and means for writing the contents of the fourth register to the address, and the actual argument of the subroutine of the program , or a debugging device characterized by high-speed access to local variables.