JPS61180344A - Step execution system for high level language - Google Patents

Abstract

PURPOSE:To carry out effectively a debug for each function by setting the step return within a step execution system of a high level language and executing it to release a breakpoint after generation of a break. CONSTITUTION:When an operator gives a command to a RAM2 for return to a point (a) of a caller, a CPU1 obtains the size of a local variable area related to the function which is presently stopped. Then the CPU1 obtains a return address with a stack storing the return address of the function from the value of the present stack pointer and the size of said variable area and extracts it. The step return is set to the extracted return address as a breakpoint and executed. In this case, the process of execution returns to the point (a) by the step return via the procedures (4) and (5). The program processing is broken automatically when the process is returned to the point (a).

Description

DETAILED DESCRIPTION OF THE INVENTION Field of Industrial Application The present invention relates to a step execution system for programming languages, particularly high-level languages written in a form similar to mathematical formulas and symbols used in everyday life.

<Summary of the Invention> The present invention incorporates a new concept of step return into a high-level language step execution system for debugging programs written in a high-level language. The system is designed to automatically break the system to improve the efficiency of debugging.

<Prior art> In general, programs written in high-level languages are debugged (d
ebug), there are some that allow step execution on a statement (line) basis, but most of them are currently executed on a function-by-function basis.

By the way, in the past, when you want to return program processing to the caller after debugging a function unit, you either have to set a new breakpointer in the caller, or you have to continue step execution. Naranaka, ivy.

Debugging a program requires a lot of man-hours, making it impossible to debug efficiently.

SUMMARY OF THE INVENTION In view of the above-mentioned problems, it is an object of the present invention to provide a step execution Mk for a high-level language that can efficiently debug function units.

Means for Solving the Problems> To achieve the above object, the present invention provides a step execution system for debugging a program written in a high-level language, in which a step is set as a breakpoint at the return address of a function. The feature is that a return is set and executed, and a break point is canceled after a break occurs.

<Example> Below are the drawings? An embodiment of the present invention will be described with reference to the following.

FIG. 1 is a schematic block diagram of a high-level language step execution system to which the present invention is applied. In Figure 1, 1
deciphers the command and performs according to the command! A microprocessor (CPU) that performs X operations, storage operations, input/output operations, and control operations, 2 memory (RAM) that stores the debugged program that is the target of tif backing, and 3 the memory that stores the debug program. (ROM), 4
5 is a debug information display device (CRT) used by the operator during debugging, and 5 is a key input device (keyboard), which are connected to a control signal bus, an address bus, and a bidirectional data bus (not shown), respectively. ing.

FIG. 2 is a configuration diagram of the program to be debugged stored in the memory 2 of FIG. 1. This program to be debugged has two functions, main (main program) and function
on A (subprogram). The subprogram includes a step return, which is a new concept described later, and is started and executed by a call instruction (call). Also, the 0 point in the main program indicates the caller,
At this 0 point, subprogram 9, function func, (A
) k is calling. Note that arrows ■ to ■ indicate the order of execution.

FIG. 3 shows a stack memory map when a so-called interrupt occurs when the function func (A) is called.

In Figure 3, 6 is the function func, a local variable used within (A) (declared within each block (procedure))
Area 7 is a return address area for storing a return address, 8 is a function func, an argument area for (A), and 9 is a stack pointer. This stack pointer 9 is used to manipulate the address of the stack memory.

Figure 4 shows the two functions main and func, the size N of the local variable area required for (A), and the location address of each function (
FIG. 3 is a configuration diagram showing an example of specific data of the first address and the last address. These local variable area size N and location address are set when compiling the program to be debugged stored in the memory 2 of FIG. 1, and are output by the compiler.

Next, the operation of returning from point 0 (execution order ■) of function func.(A) to point 0 (caller) of function main through the entire step execution system of the high-level language described above will be described.

First, the operator issues a command request to return to the calling source (point 0) to the debug program (memory 3) via the keyboard 5t. Upon receiving this command, the CPU reads data from the debug program (memory 3) in accordance with the control signal, and uses the current program counter value and the data shown in Figure 4 of the debugged program (memory 2) to determine the current The size Nt of the local variable area 6 related to the stopped function is determined.

Next, the CPU 1 determines the return address in the stack in which the return address of the function is stored from the current value of the stack pointer 9 and the previously determined size N of the local variable area 6, and retrieves it. Then, a step return is set as a breakpoint (breakpaint) at the retrieved return address (return address 9) and executed. The execution process at this time returns to point 0, which is the calling source, through the steps of the execution order (1) and (2) by step return. Then, when the point returns to 0, the program processing automatically breaks.

At this time, CPU1 compares the value of the program counter holding the address next to the address of the currently executed instruction with the previous return address to confirm that the point is 0 (caller). After confirming this, the break pointer is automatically canceled. Therefore, execution up to a step return in the calling function related to the function to be debugged can be performed without setting a breakpoint.

<Effects of the Invention> As detailed above, the present invention incorporates a new concept of step return into a high-level language step execution system, and when program processing returns to the calling source based on this command request, Since the process automatically breaks, unlike conventional methods, when returning to the caller, the operator has to check the caller one by one, then set a breakpoint and execute the process. is no longer necessary, and the number of man-hours required when debugging a program can be significantly reduced, which is highly effective in improving debugging efficiency. Furthermore, it is possible to improve the productivity of the program.

[Brief explanation of the drawing]

FIG. 1 is a schematic block diagram of a high-level language step execution system to which the present invention is applied, FIG. 2 is a configuration diagram of a program to be debugged, and FIG. 3 is a configuration diagram of a stack memory specified by a stack pointer. FIG. 4 is a configuration diagram showing an example of data to be processed output by the compiler. 1...CPU (microprocessor), 2...Memory (RAM), 3...Memory (ROM), 4...Denokulug month information display device (cRT), 5...Key human power device , 916. Stack pointer, N...Local variable area size.

Claims (1)

[Claims] A step execution system for debugging programs written in a high-level language, which is characterized by setting a step return as a breakpoint at the return address of a function, executing it, and canceling the breakpoint after a break occurs. step execution system.