JPS6148738B2 - - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION The present invention relates to a program control method for an information processing apparatus having an address stack that can also be used as a register file.

Generally, in small-sized information processing devices, an address stack for interrupts or subroutines is sometimes used as a register file in which a program temporarily holds data. In such a case,
If pop-up and push-down are not used in a one-to-one correspondence, that is, if the depth of the nesting structure is incorrectly grasped, the program will run out of control.
This effect is not limited to the program that made the mistake if multiple programs share the same stack.

An example of this program runaway will be explained with reference to FIGS. 1 and 2. Figure 1 shows the address stack STK and stack pointer SP, which are of a last-in-first-out type and are also used as register files.
It is stored in each entry ENT distinguished by SP values n-1, n, n+1, . . . . Pointer SP is incremented by one (pushdown) each time a write is made to the stack STK, and decremented by one (popup) each time a read is made from the stack. In Figure 2, there is a subroutine call during the execution of program A, and before moving to the next address a, program B
This is an example of a case where it is decided to carry out the following. The memory storing program A is accessed while an address counter (not shown) is incremented (not necessarily +1, but it is simply referred to as such here), and the program A in the memory is accessed.
Read each instruction one after another, decode and execute it,
If the call instruction is read when the address advances to a-1 and jumps to program B, then program A is used to return to program A.
Write the next address a to the stack STK, write the start address of program B to the address counter, access the memory at that address to read the program B, and similarly increment the address counter by 1 to start executing the program. enter. Assume that program B uses stack STK as a register file and temporarily stores data b, c, and d in entries ENT with pointer values n, n+1, and n+2, respectively. This data b, c,
If d is read out in its entirety in the subsequent execution process of program B, the value of pointer SP will have returned to n-1, so if program B's subroutine return instruction is read out and executed now, the address counter will be updated. Address a is read from the stack STK by the instruction of the stack pointer pointing to entry n, and this is restored to the address counter, allowing program A to resume processing from address a (indicated by a broken line). However, if the depth of the nest (or stack) is misunderstood due to a mistake in the creation of program B, for example, if the process ends and the subroutine returns after just reading data d, the entry with the value n+2 pointed to by the stack pointer SP In order to return with data C as the address, the program will jump to the address corresponding to data C (if applicable), and of course it will not be possible to resume processing of program A, and a completely unexpected program will be executed or the program Execution is halted. In other words, a program runaway occurs.

The present invention provides such an A, B multi-program processing device in which, in the above example, another program A is adversely affected by a nesting depth error made when program B uses an address stack as a register file. It is designed to prevent errors from occurring and to limit the error to only the program B that made the error.It is characterized by a last-in, first-out storage device that is shared as an address stack and a data stack and has multiple entries. , means for displaying whether the content of each entry in the storage device is an address or data, and means for returning to the subroutine using the content read from the storage device as an address according to instructions from a program, and when returning to the subroutine, the above-mentioned The point is that only the content displayed as an address by the display means is valid and the return is made to the address of the content.

Hereinafter, one embodiment of the present invention will be described with reference to FIGS. 3 and 4. In the present invention, stack STK
For each entry ENT in ENT, a means is provided for displaying whether the entry currently stores an address or data. In the example shown in FIG. 3, this is realized by the address/data identification flag F. In this example, if F=0, the content in the corresponding entry ENT (a in Figure 3) is an address, and if F=1, the content in the corresponding entry ENT (b to d in the same figure) is data. . Referring to this flag F, as shown in Figure 4, when a subroutine return instruction occurs in the same process as in Figure 2, the value of the stack pointer SP is returned to F = 0 (n-1). Therefore, address a can be reliably read. Therefore, runaway of the program is prevented, and program A continues to be executed without any trouble.

As described above, according to the present invention, in a processing device that uses the same stack for storing addresses and data in multiple programs, data in the stack is mistaken for an address due to misjudgment of the nesting depth, resulting in a program runaway. It has the advantage of preventing In addition, in the example, two multi-programs A and B were given, but this example includes A, B, C,
There may be many such as D... In this case, the address stack will contain a large number of return destination addresses, and data will be jammed between them (such cases may occur), but even in such cases, if the present invention is applied, data can be saved. It is possible to reliably return to the address without reading, which is effective in preventing program runaway.

[Brief explanation of the drawing]

Fig. 1 is an explanatory diagram of a conventional stack for both address and data, Fig. 2 is an explanatory diagram of the operation when the same stack is shared by multiple programs, and Figs. 3 and 4 show an embodiment of the present invention. 3 is an explanatory diagram of the stack, and FIG. 4 is an explanatory diagram of the operation. In the diagram, STK is stack, ENT is entry, F
is an address/data identification flag.

Claims (1)

[Claims] 1. A last-in, first-out storage device that is shared as an address stack and a data stack and includes a plurality of entries; and means for displaying whether the content of each entry in the storage device is an address or data;
and means for returning to the subroutine using the content read from the storage device as an address according to instructions from the program, and when returning from the subroutine, the display means returns to the content displayed as an address and returns to the address of the content. A subroutine control method featuring: