JPH01130234A - Fault searching system - Google Patents

Abstract

PURPOSE:To save the trouble for searching a fault by storing the input information immediately before a jump to an external subroutine, and the output information immediate after its return, in the first area of a memory and the second area of the memory, respectively. CONSTITUTION:Input information immediately before a jump to an external subroutine is stored in the first area 1 of a memory by a store means 3, and output information immediately after its return from the external subroutine is stored in the second area 2 of the memory. In such a state, a runaway related to the external subroutine is decided due to a fact that there is no storage in the area 2, and by looking at the contents of the area 1, an error of the input information is decided.

Description

[Detailed Description of the Invention] [Summary] Regarding a fault search method that searches for an external subroutine that causes a runaway when a computer executes a program that has an instruction to jump to an external subroutine, when a runaway occurs, which external subroutine is The purpose of this system is to provide a failure search method that allows you to quickly and easily find out which external subroutine is defective or which external subroutine input information is incorrect.Input information immediately before jumping to an external subroutine is stored in the first area of memory. A storage means is provided for storing output information immediately after returning from an external subroutine in a second fief area of the memory.

[Industrial application field]

The present invention relates to an improvement in a fault search method for searching for an external subroutine that causes a runaway when a computer executes a program that has an instruction to jump to an external subroutine.

As shown in FIG. 4, a computer usually includes at least a processor 4. ROM5. - Consists of memory 6, the program is stored in ROM 5, and when executing the program,
The processor 4 reads this and executes it using an area of the memory 6, etc.

When the processor 4 executes a program that has an instruction to jump to an external subroutine stored in the ROM 5, it finds the external subroutine that will cause a failure if a runaway occurs, and then determines whether the external subroutine is defective or jumps to the external subroutine. It is determined whether the input information stored in the register immediately before the input is defective or not, but it is desirable that this fault search can be done quickly and without much effort.

[Conventional technology]

FIG. 5 is a diagram showing an example of a main program having an instruction to jump to an external subroutine and a program for analyzing a conventional main program; (A) shows the main program;
(B) is a program for analyzing the main program, (
C) indicates a memory area. FIG. 6 is a diagram showing an example of a program having multiple instructions for jumping to external subroutines.

For example, as shown in FIG. 5(A), an instruction related to jumping to an external subroutine is stored at memory address 5000-5002.
The contents are respectively set data 500 to register R1, data 1000 to register R2, jump to an external subroutine with label DGMSGED, and write the return destination address (next address 5003) to register R.
Set it to 7.

In addition, the external subroutine with label DGMSGED stores the contents of register R1 in memory area AAA2, and stores the contents of register R1 in memory area AAA.
Assume that the contents of 2 are stored in memory area BBH.

Then, when executing this program, register R1
, R2 is used as input information, and the command at address 5002 jumps to the external subroutine with label DGMSGED.
The SGED external subroutine is a copy instruction that stores the contents of register R1 in memory area AAA and the contents of register R2 in memory area BBB, so even if the subroutine is executed, the contents of registers R1 and R2 will not be outputted. 5003 when the subroutine is completed without converting to d.
Return to the address and execute the command at this address.

At this time, if there is a defect in the program, a runaway will occur, but in order to find this defective part, we have a program to analyze the main program as shown in (B), and store the currently executing instruction in memory. The address of the instruction currently being executed is stored in the memory area psw.

When a runaway occurs, in order to find the fault in the program,
Using a program that stops instruction execution, restarts the main program, and stops instruction execution when the address of the instruction being executed stored in the memory area psw becomes equal to the specified address, ), if there is one instruction that jumps to an external subroutine, the address 5003 is specified as the return destination after execution of the external subroutine.

If the runaway has occurred in connection with an external subroutine, the instruction execution will not return to address 5003, indicating that there is a defect in connection with the external subroutine.

In this case, the cause of the failure is that the input information stored in registers R1 and R2 (usually there are about 10 registers) immediately before jumping to the external subroutine is incorrect, or that the external subroutine itself is defective. There are cases.

Therefore, stop the instruction execution again, start the main program again, specify address 5001 immediately before jumping to the external subroutine, and stop the instruction here.
Look at the contents stored in registers R1 and R2.
``If this content is incorrect, this is the cause of the runaway; if it is not incorrect, it turns out that the external subroutine itself is defective.

As shown in FIG. 6, if there are multiple instructions to jump to external subroutines, for example, four, No. 1 to No. 4, the above operation is repeated sequentially from No. 1 to No. 64, and the input information to which external subroutine is determined. Find out what is wrong or which external subroutine itself is bad.

[Problem that the invention seeks to solve]

However, in the conventional fault search method described above, when a runaway occurs, the instruction execution is repeated at least three times, which increases depending on the number of instructions that jump to external subroutines, so there is a problem that it is troublesome and time consuming. . .

According to the present invention, when a program with a jump instruction to an external subroutine is executed and a runaway occurs, it is possible to quickly and easily find out which external subroutine is defective or which external subroutine has incorrect input information. The purpose is to provide a fault search method.

[Means for solving problems]

FIG. 1 is a block diagram of the principle of the present invention.

As shown in Figure 1, when a computer executes a program that has an instruction to jump to an external subroutine, input information immediately before jumping to the external subroutine is stored in the first area 1 of memory, and immediately after returning from the external subroutine. storage means 3 for storing the output information of in the second area 2 of the memory;
The configuration includes the following.

[Effect]

According to the present invention, the storage means 3 stores the input information immediately before jumping to the external subroutine (the contents stored in all available registers) in the first area l of the memory, and also stores the input information from the external subroutine (contents stored in all available registers) The output information immediately after the return (contents stored in all registers available in the external subroutine) is stored in the second area 2 of the memory.

In this way, if a runaway occurs related to an external subroutine, nothing will be stored in the second area 2, so you can know that a runaway has occurred related to an external subroutine, and by looking at the contents of the first area 1, input It is determined whether the information is incorrect, and this indicates whether the input information or the external subroutine is defective.

If there are multiple instructions that jump to external subroutines, each time this instruction comes, the first and second areas 1 and 2 of the memory are
However, if you look at the contents of the 1st and 2nd areas 1.2, for example, the 1st area contains input information to the external subroutine of N002, and the 2nd area 2 contains No.
If the output information of external subroutine 1 is stored,
A runaway has occurred due to the external subroutine No. 2, and in this case, if the contents of the first area are incorrect, No. 22
It turns out that the input information to the external subroutine is wrong and the program is out of control.

Therefore, it can be determined that the external subroutine is defective or the input information of which external subroutine is incorrect.

That is, since the fault search can be performed without particularly stopping program execution, the fault search can be performed quickly and without much effort.

〔Example〕

FIG. 2 is a flowchart of a fault search program according to an embodiment of the present invention, and (A) shows a memory area.

In the case of the present invention, when a program including an instruction to jump to an external subroutine is executed, the program shown in FIG. 2 is also started.

In the following, the main program shown in FIG. 5(A) will be explained in accordance with the program shown in FIG. 2.

Same as the conventional method (in step 1, the currently executed instruction is stored in the memory area ir, and in step 2, the address of the currently executed instruction is stored in the memory area psw).

Next, in step 3, it is determined whether the instruction is to jump to an external subroutine, and if so, in step 4, the return address of register R7 is stored in memory area r7, and in step 5, the instruction is to jump to an external subroutine. Input information just before jumping to the subroutine (contents of all available registers)
is stored in the memory area A, the process returns to step 1, the same thing as above is executed in steps 1 and 2, and it is determined in step 3 whether the instruction is to jump to an external subroutine.

At this time, if not (usually not), proceed to step 6, check whether the address of the currently executing instruction is equal to the return address stored in memory area r7, and if not, return to step 1, described above. Repeat that,
If they are equal, the process advances to step 7, and the output information (contents of all registers usable by the external subroutine) upon return from the external subroutine is stored in memory area B.

In this way, when a runaway occurs, nothing will be stored in memory area B, so you can know that the runaway is related to an external subroutine, and by looking at the contents of memory area A, you can check whether the input information is incorrect. If it is incorrect, it is determined that the input information is the cause, and if it is not incorrect, it is determined that the external subroutine is defective.

As shown in Figure 6, when there are multiple instructions to jump to an external subroutine, the contents written to memory areas A and B are rewritten each time an instruction to jump to an external subroutine arrives; For example, if memory area A contains input information to an external subroutine No. 2, and memory area B stores output information from an external subroutine No. 1, then N0
If a runaway has occurred due to the external subroutine of 02, and the contents of memory area A are incorrect in this case, No. 2
It turns out that the input information to the external subroutine is wrong and the program is out of control.

Therefore, it can be determined which external subroutine is defective or whose input information is incorrect.

FIG. 3 is a flowchart of a fault search program according to another embodiment of the present invention, and (A) shows the memory area.

The program shown in FIG. 3 is applied when there are multiple instructions to jump to an external subroutine as shown in FIG. 6.The program shown in FIG. , equivalent to step 6 in FIG.

Therefore, the different points will be explained.

In this case, each time a command to jump to an external subroutine is received and the return address of register R7 is stored in memory area r7 in step 4, the counter is incremented by one, and in step 6 the external subroutine is The input information immediately before jumping to the subroutine is stored in the memory area A plus the count value, which is the address area A+1. A+2.・
... and when the address of the currently executing instruction is equal to the return address stored in memory area r7, in step 8, the output information at the time of return is sent from the external subroutine. Area B + 1° 8 + 2 at the address of memory area B plus the count value. The point is that it is stored in...

In this way, as shown in (A), for each command to jump to an external subroutine, the previous input information will be stored in the memory area A, A+1, A+2°, etc., and the output information immediately after return. are memory areas B, B+1.B+2.
... is stored in...

Therefore, since nothing is written to the output information storage area corresponding to the external subroutine that is causing the runaway, for example, B+3, it is found that the part related to the external subroutine at the instruction N004 is defective, and the memory area A+3 is found to be defective. By looking at the input information, you can see if the input information is incorrect.
It can be determined which external subroutine is defective or whose input information is incorrect.

In the case of Figure 6, instructions No. 1 and No. 004 use the same external subroutine even though the input information is different, so the method in Figure 2 can determine which external subroutine is defective. Although it is difficult to search to see if the input information is incorrect, in the case of FIG. 3, the information is stored in memory areas on both sides, so it can be searched clearly.

〔Effect of the invention〕

As explained in detail above, according to the present invention, when a program with a jump instruction to an external subroutine is executed and a runaway occurs, it is possible to determine which external subroutine is defective or the input information of which external subroutine is incorrect. This has the effect of allowing you to search quickly and without much effort.

[Brief explanation of the drawing]

FIG. 1 is a principle block diagram of the present invention. FIG. 2 is a flowchart of a fault search program according to an embodiment of the present invention. FIG. 3 is a flowchart of a fault search program according to another embodiment of the present invention. is a block diagram of an example computer; FIG. 5 is a diagram showing an example main program with an instruction to jump to an external subroutine and a program for analyzing a conventional main program; FIG. 6 is an example computer block diagram. FIG. 2 is a diagram showing a program having multiple instructions for jumping to external subroutines. In the figure, 1 is a first fii area of the memory, 2 is a second area of the memory, 3 is a storage means, 4 is a processor, and 5 is a ROM. Figure 4: Block diagram of an example computer

Claims (1)

[Claims] When a computer executes a program having an instruction to jump to an external subroutine, input information immediately before jumping to the external subroutine is stored in a first area (1) of the memory, and when returning from the external subroutine, input information is stored in the first area (1) of the memory. A fault search method characterized in that a storage means (3) is provided for storing immediately after output information in a second area (2) of a memory.