JPH05324393A - Debugging system - Google Patents

Abstract

PURPOSE:To improve debugging performance by holding the break point of a debugging object program stored in a shared memory even while a debugging monitor is traveling. CONSTITUTION:Whether or not an instruction to be changed is stored in a break point control table is investigated (PS120) and when it is stored, the corresponding instruction to be replaced stored in the break point control table is changed (PS121). When the instruction is not stored in the break point control table, a shared bus is acquired (PS122), the corresponding instruction of the debugging object program on the shared memory is changed (PS123) and thereafter the occupied shared bus is released (PS124). Then, when the break point is set at a traveling starting address, the shared bus is acquired (PS151) and the instruction to be replaced corresponding to the traveling starting address is acquired from the break point control table to be written in the traveling starting address on the shared memory.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a debugging system, and more particularly to a debugging system for a program operating on a shared memory type multiprocessor.

[0002]

2. Description of the Related Art In order to debug a program, instead of a plurality of instructions scattered at appropriate points in the progress of the program (this is called a breakpoint and the address of the breakpoint is called a breakpoint address), It is usual to insert a breakpoint instruction and interrupt the progress of the program when the instruction is reached and transfer control to the debug monitor to search for a bug. The instruction of the program to be debugged, which is replaced by the breakpoint instruction, is hereinafter referred to as the replaced instruction.

A breakpoint management table is used to manage the breakpoints, which stores the unique identifiers of the respective breakpoints, the corresponding breakpoint addresses, and the instructions to be replaced.

A conventional debugging method for a program operating on a shared memory type multiprocessor has been realized as an extension of a debug monitor for a single processor.
Before describing the extension method, first, a method of configuring a debug monitor for a single processor, which has been widely used in the past, will be described with reference to FIG.

Program step (hereinafter referred to as PS) 1
Reference numeral 60 is a debug target program, and PS other than that is a debug monitor. A transition is made from PS160 to PS100 when a breakpoint instruction normally arranged in the debug target program is executed.

PS 100 and PS 102 are for preventing the contents of the registers used by the debug monitor in the debug target program from being destroyed.

In the PS200, the breakpoint instruction in the program to be debugged is replaced with the corresponding replaced instruction in the breakpoint management table. As a result, the instruction reference / instruction change command can be realized by simple reference / change to the memory storing the debug target program (PS210, PS220). Also,
Breakpoint setting / deletion commands can only be added / deleted in the breakpoint management table (P
S230, PS240).

The embedding of the breakpoint instruction in the debug target program is collectively performed immediately before the running of the debug target program (PS251).

In the execution command of the program to be debugged, first a single step (PS
250), the instruction existing at the breakpoint address, that is, the replaced instruction is saved in the breakpoint management table by referring to the breakpoint management table, and the breakpoint instruction is embedded therein instead (PS251), The contents of the register are restored to those of the debug target program (PS102), and control is transferred to the debug target program (PS160).

In FIG. 2, five commands are separated by the PS 101 and executed, but some debug commands such as register reference / change may exist.

Conventionally, there have been the following two methods for expanding the debug monitor for a single processor to configure a debug monitor for a shared memory type multiprocessor.

1. By inserting a debug monitor running right acquisition function immediately after PS100 and a debug monitor running right release function immediately before PS102, the running of the debug monitor main body is exclusively controlled between the processors.

2. Immediately after PS100, a request to stop running the debug target program is issued to all processors other than the own processor. After confirming that all the debuggee programs are stopped, execute the main part of the debug monitor only with the local processor. Immediately before the PS 102, a running start request of the debug target program is issued to all processors other than the own processor.

According to the above method, the debug monitor for the shared memory type multiprocessor could be easily realized without modifying the main body of the debug monitor for the single processor.

[0015]

SUMMARY OF THE INVENTION 1. The conventional debug method described above. Then, while running the debug monitor, PS of Figure 2
Since each break point instruction of the debug target program stored in the shared memory by 200 is replaced by the replaced instruction, the breakpoint target instruction does not exist in the debug target program, and the program is running in the debug monitor. If there is a processor, the debug target program is run without breakpoints to other processors running the debug target program, and the debug target program is debugged at the breakpoint on the shared memory multiprocessor. There was a drawback that the original purpose of debugging, that is, interrupting the program and investigating the bug, could not be achieved.

In addition, the above-mentioned conventional debug method 2.
However, since all the debug target programs are forcibly stopped, there is a drawback that you cannot debug if the bug cannot be reproduced unless the debug target program entered in the debug monitor operates in real time. It was

An object of the present invention is to provide a debugging method capable of remarkably improving the debugging performance even on a shared memory multiprocessor by holding a breakpoint of a program to be debugged stored in the shared memory even while the debug monitor is running. Especially.

[0018]

According to a debugging method of the present invention, in the debugging method of a program operating on a shared memory type multiprocessor, a unique identifier of each breakpoint set in the program to be debugged and its setting position are set. A breakpoint management table for storing the indicated breakpoint address and the replaced instruction which is the instruction of the debug target program which is replaced by the break point instruction at the breakpoint address and which is specified according to the input of the breakpoint setting command The instruction of the debug target program on the shared memory at the specified breakpoint address is stored in the breakpoint management table together with the breakpoint address, and the instruction is stored in the debug target program instead. The breakpoint instruction is written, the breakpoint management table is referred to in response to the input of the breakpoint deletion command, the replaced instruction is returned to the breakpoint address corresponding to the specified breakpoint identifier, and then the corresponding breakpoint information is written. Of the instruction of the debug target program which is deleted from the breakpoint management table and is stored in the shared memory in response to the input of the instruction reference command and the reference of the replaced instruction which is stored in the breakpoint management table. If any of the instructions is changed and the instruction to be changed in response to the input of the instruction change command is in the breakpoint management table, the corresponding replaced instruction is changed, and if it is not in the breakpoint management table, the instruction change command is input. The processor starts the exclusive use of the shared memory, changes the corresponding instruction of the debug target program stored in the shared memory, and thereafter ends the exclusive use of the shared memory by the processor, and the debug When a break point instruction is not set in the running start address of the debug target program in response to the input of the execution command of the target program, the program starts running from the running start address and responds to the input of the execution command of the debug target program. If a breakpoint instruction is set at the running start address of the debug target program, the processor to which the execution command is input starts exclusive use of the shared memory and refers to the breakpoint management table. Corresponds to the start address Write the replaced instruction to the running start address on the shared memory, single step the debug target program at the running start address, and write the breakpoint instruction again to the location of the running start address on the shared memory. The exclusive use of the shared memory is terminated, and the debug target program is started to run from the address immediately after the single step.

[0019]

According to the present invention, the break point instruction is not extracted from the program to be debugged in the shared memory even while the debug monitor is running, so that the break point is ignored even if there is a processor running the debug monitor. I am trying not to However,
In the single-step operation immediately before the debug target program starts running, it may be necessary to temporarily restore the replaced instruction to the debug target program in the shared memory. While the instruction is being monopolized, the breakpoint instruction and the replaced instruction are replaced and the single step operation is performed so that another processor does not ignore the breakpoint during this operation. Further, when the instruction change command is executed in consideration of the case where the instruction is longer than the word length of the computer, when the instruction on the shared memory is changed, the shared memory is exclusively used to prevent a malfunction when the instruction is changed.

In the debug monitor for a single processor, the original instruction is always present in the debug target program on the memory when the debug target program is stopped. However, in the multiprocessor debug monitor of the present invention, the instruction The original is a shared memory debug target program and a breakpoint management table.
Therefore, when executing the instruction reference command and the instruction change command, it is possible to deal with this.

In the debug monitor for a single processor, the replacement of the break point instruction and the replaced instruction is performed collectively at the time of stopping and starting the execution of the program to be debugged. Is executed when the breakpoint setting command and the breakpoint deletion command are executed.

[0022]

Embodiments of the present invention will now be described with reference to the drawings.

FIG. 1 is a flow chart showing an embodiment of the debugging method of the present invention.

The debug system of the present embodiment assumes a shared bus / shared memory type multiprocessor, and realizes exclusive use of the shared memory by the specific processor by continuously acquiring the shared bus by the specific processor. There is. In addition, the break point instruction is less than or equal to the word length of the computer.

Execution of the breakpoint setting command
First, the instruction of the program to be debugged in the shared memory pointed to by the breakpoint address specified by the command is stored in the breakpoint management table together with the breakpoint address (PS130), and then in the shared memory pointed to by the breakpoint address. Write a breakpoint instruction to the location (PS131).

Execution of the breakpoint deletion command
First, the breakpoint address and the replaced instruction are acquired by searching the breakpoint management table with the breakpoint identifier specified by the command (PS140). Next, the replaced instruction is returned to the location on the shared memory pointed to by the breakpoint address (PS141). After that, the breakpoint information corresponding to the breakpoint identifier is deleted from the breakpoint management table (PS142).

To execute the instruction reference command, it is first checked whether the instruction to be referred to is stored in the breakpoint management table (PS110). When it is stored in the breakpoint management table (PS11
(YES branch of 0), refer to the corresponding replaced instruction stored in the breakpoint management table (PS11
1). When it is not stored in the breakpoint management table (NO branch of PS110), the corresponding instruction of the debug target program in the shared memory is referenced (P
S112).

In executing the instruction change command, the shared memory is exclusively used in order to prevent a malfunction when changing the instruction in consideration of the case where the instruction is longer than the word length of the computer. First, it is checked whether the instruction to be changed is stored in the breakpoint management table (PS120). When stored in the breakpoint management table (YES branch of PS120), the corresponding replaced instruction stored in the breakpoint management table is changed (P
S121). When it is not stored in the break point management table (NO branch of PS120), the shared bus is acquired by PS122, the corresponding instruction of the debug target program on the shared memory is changed (PS123), and then occupied. The shared bus is released (PS124).

In the execution command of the program to be debugged, first, whether or not a break point is set at the running start address is checked using the break point management table (PS150).

As a result, when it is determined that the debug target program is not set, the register value of the debug target program is immediately restored (PS102), and the control is transferred to the debug target program.

When a break point is set at the running start address, the shared bus is first acquired (P
S151), The replaced instruction corresponding to the running start address is acquired from the breakpoint management table, and this is written to the running start address on the shared memory (PS152).
The debug target program is single-stepped at the run start address (PS153), the breakpoint instruction is written again to the place of the run start address on the shared memory (PS154), and then the shared bus is released (P
S155). Then, restore the contents of the register (P
S102), the debug target program is started to run from the address immediately after the single step.

Although the register contents are restored immediately before the single step and the register contents are saved immediately after the single step, the description thereof is omitted.

In processing the instruction reference / modification command, a plurality of instructions can be collectively processed by using the buffer memory to improve the processing efficiency.

In processing the instruction change command, the shared bus may be acquired first before the processing, and the shared bus may be released after the processing is completed.

[0035]

As described above, according to the debugging method of the present invention, the debug performance is maintained even on the shared memory type multiprocessor by holding the breakpoint of the program to be debugged stored in the shared memory while the debug monitor is running. It has an effect that it can be remarkably improved.

[Brief description of drawings]

FIG. 1 is a flowchart showing an embodiment of a debugging method of the present invention.

FIG. 2 is a flowchart showing an example of a conventional debugging method.

[Explanation of symbols]

PS100-102, 110-112, 120-12
4, 130-131, 140-141, 150-15
5, 160, 210, 220, 230, 240, 25
0,251 Flow chart step

Claims (1)

[Claims] 1. In a debugging method of a program operating on a shared memory multiprocessor, a unique identifier of each breakpoint set in the debug target program and a breakpoint address indicating the setting position and the breakpoint address are present. A breakpoint management table is provided for storing a replaced instruction which is an instruction of the debug target program replaced by a break point instruction, and is on the shared memory at a breakpoint address specified according to an input of a breakpoint setting command. The instruction of the program to be debugged is stored in the breakpoint management table together with the breakpoint address, and instead, a breakpoint instruction is written to the program to be debugged to In response to the input of the delete command, the breakpoint management table is referenced, the replaced instruction is returned to the breakpoint address corresponding to the specified breakpoint identifier, and then the corresponding breakpoint information is deleted from the breakpoint management table. Changing the instruction by referring to the instruction of the debug target program stored in the shared memory or the replaced instruction stored in the breakpoint management table in response to an instruction reference command input. When the instruction to be changed in response to the input of the command is in the breakpoint management table, the corresponding replaced instruction is changed, and when it is not in the breakpoint management table, the processor in which the instruction change command is input changes the shared memory Exclusive use Start and change the corresponding instruction of the debug target program stored in the shared memory, then end the exclusive use of the shared memory by this processor, and in response to the input of the execution command of the debug target program. When no breakpoint instruction is set in the run start address of the debug target program, the program starts running from the run start address, and the run start address of the debug target program is set according to the input of the execution command of the debug target program. When a break point instruction is set, the processor to which the execution command is input starts exclusive use of the shared memory and refers to the break point management table to replace the replaced instruction corresponding to the running start address. Run on the shared memory Write to the start address, single-step the debug target program at the run start address, write a breakpoint instruction again to the location of the run start address on the shared memory, and then end the exclusive use of the shared memory by the processor A debugging method characterized in that the program to be debugged is started from the address immediately after a single step.