JP2500804B2 - calculator - Google Patents

Description

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a computer having a trap function, and more particularly to improvement of a software trap processing system.

[Conventional technology]

As a method of transferring the control of the program processed by the computer to another program or routine, there are a subroutine call, an interrupt, and a trap. Of these, traps are interrupt requests that are internally generated as a direct and immediate result of instruction execution. They include detection of exceptional conditions by memory management, execution of illegal operations and undefined instructions, overflow of operation results, division by zero, and debugging. Breakpoints and program trace execution, software
It is generated by executing the trap generation instruction. Of these, the software trap generation instruction is for intentionally generating a trap in a program to call a trap processing program, and has a property similar to that of a subroutine call.

The software trap generation instruction is used when the program execution environment is changed, and particularly when a service program prepared in the system is called. For example,
Intel Intel 16-bit microprocessor iAPX86
INT instruction, TRAP instruction of Motorola's 16-bit microprocessor MC68000, or US National Semiconductor's 32-bit microprocessor NS32032
SVC instruction corresponds to this software trap generation instruction.

Control of program call by subroutine call, interrupt, and trap matches well with the stack mechanism that accumulates data in the last-in / first-out format. When a subroutine is called from the program currently being executed, or when control is transferred to another program due to an interrupt or trap, the return address and necessary information are saved in the stack, and the stack is stored at the end of the subroutine or interrupt or trap processing. To restore the information stored in
Execution resumes from the instruction at that address. With such a mechanism, the last saved information is restored first, so even if a program is called in a nested manner, control is always returned to the caller when the processing of a routine or program ends. Be done. Most of the current computers use this stack mechanism to perform the above-mentioned control.

FIG. 4 is a block diagram of a conventional computer that performs such call control by a stack mechanism. (7) is a main memory, (3) is a program counter for holding an address in the main memory in which an instruction to be executed is stored,
(2) is a stack pointer indicating the highest position of the data stored in the main memory (7) in the last-in-first-out format, (4) is at least one or more general-purpose or dedicated registers, ( 5) is a control register including a control flag and a status flag of the computer, and (6b) is a control means. The main storage device (7) is provided with a stack area (8) for storing data in the last-in / first-out format, and the stack pointer (2) is set to the highest position of the data stored in this area. ) Is pointing. The control means (6b) interprets the instruction fetched from the position on the main storage device (7) indicated by the program counter (3) and controls the execution of the instruction, and
Counter (3), stack pointer (2), register (4), control register (5) and main memory (7)
The data transfer control between the device and the device is performed.

Next, the operation for each execution of the software trap generation instruction in such a computer will be described. FIG. 5 is a state diagram of the stack in the main memory before and after the execution of the software trap generation instruction of the computer. Immediately before the execution of the software trap generation instruction, the stack pointer (2) holds the stack position [S0], and the arrow (9)
As shown by, indicates the highest position of the data accumulated in the stack area (8) by the execution of the program up to now. When the software trap generation instruction is executed, the necessary information is saved between the stack position [S0 + 1] and the stack position [S1b] in the stack area.
The contents of the stack pointer (2) are updated to the stack position [S1b] as indicated by the arrow (10b). Then, the start address of a specific program determined by each computer or operating system is stored in the program counter (3). Therefore, the next instruction is fetched from the main memory address stored in the program counter (3) and executed. The control described above is performed by the control means (6b).

Information stored between the stack position [S0 + 1] and the stack position [S1b] includes the contents of the program counter (3) (return address), the contents of the control register (5), the general-purpose or dedicated register (4). , The specific data in the main memory, and so on. For example, the Motorola MC68000 saves the return address and the contents of the control register.

In such a computer, the stack grows dynamically every time a program or subroutine is called.
For example, when the program A calls the system program S by a software trap generation instruction and the called system program S calls the subroutine B, the stack changes as shown in FIG. The stack pointer (2) points to the stack position [SP0] as indicated by the solid arrow (30) immediately before the execution of the software trap generation instruction, but the return address is set by the execution of the software trap generation instruction. When the contained information is stored in the area (21b) which is the top of the stack, the stack position [SP1b] is pointed to as shown by the broken arrow (31b). Further, if the area (22) is used for some purpose when the program S is executed, the stack pointer is indicated by a broken arrow (32) immediately before the subroutine B is called from the system program S. And indicates the stack position [SP2]. Then, when subroutine B is called, the information including the return address is stored in the area (23) at the top of the stack, and the stack pointer points to the stack position [SP3] as indicated by the broken arrow (33). become.

In this example, it is assumed that the execution of the subroutine B is controlled by the information of the program A saved in the area (21b) by the software trap generation instruction.
For example, it is conceivable that the area (21b) contains identification information for permitting interrupts, and the permission for interrupts for interrupt requests generated during the execution of the subroutine B is determined based on this identification information. The following two methods can be considered for processing in such a case.

One is a method of referring to the identification information from the information saved in the area (21b) by the software trap generation instruction.

To do so, first, at the time of subroutine call, trap and interrupt, it is necessary to save the stack position indicating the storage location of the information saved at the time of the previous subroutine call, trap and interrupt together with the return address. Then, when the identification information of the area (21b) is referred from the subretin B, the stack position indicating the area (21b) is known from the information saved in the area (23), and the target identification information is obtained from the result. You must take the procedure of referencing.

The other is a method of passing the identification information used in the subroutine B as a parameter at the time of each call. For that purpose, when the subroutine B is called from the system program S, a procedure of copying the identification information in the area (21b) to the area (23) must be taken. In this case, the reference of the identification information from the subroutine B refers to the copy of the original identification information in the area (23).

When the number of stages of calls is small as in this example, the extra procedure for referring to the identification information does not become a problem,
When referring to the identification information from a subroutine called in a nested manner or a subroutine called recursively in any number of stages, this extra procedure greatly reduces the processing efficiency. Further, in the latter method, the efficiency at the time of referring to the identification information is better than that in the former method, but since the identification information is copied for each call, an unnecessary storage area for copying is required. This waste increases as the size of the identification information increases and the number of nesting stages of the call increases.

[Problems to be solved by the invention]

In the prior art, when executing a program or subroutine called directly or indirectly by a software trap generation instruction, the information of the calling program saved in the main memory when the software trap occurs is referred to. Is very difficult, and there is a problem that fine control such as interrupt permission is complicated processing.

The present invention has been made to solve the above problems, and when a program or subroutine called directly or indirectly by a software trap generation instruction is executed, a software trap generation occurs. It is an object of the present invention to obtain a computer that can easily refer to the information of the calling program saved in the main storage device at times.

[Means for solving problems]

A computer according to the present invention is a stack memory of a first-in first-out type that temporarily stores data held in a register when a program call including a software trap generation instruction occurs, and a program call,
First holding means for updating and holding a stack address indicating a stack completion position of the stack memory in which data including a return address for returning to the calling program is saved, and generation of a software trap generation instruction Only when, the second holding means for updating and holding the stack address indicating the stack completion position of the stack memory in which the data including the return address for returning to the calling program is saved is stored; When the second software trap generation instruction is generated during execution of the software trap generation instruction, data including a return address for returning to the calling program and the first storage stored in the second holding means. The stack address and the stack address are saved in the stack memory to indicate the stack completion position. Wherein the second stack address second
And a control means for storing it in the holding means.

[Action]

The second holding means in the present invention is software.
The storage location of the information saved in the main memory when a trap occurs is held, and the information is easily referred to when a program or subroutine called directly or indirectly by a software trap generation instruction is executed.

The control means according to the present invention saves the execution state of the program before executing the software trap generation instruction, the contents of the software trap processing dedicated pointer or any other information to the main storage device by the stack mechanism. Then, the storage location is stored in the software trap processing dedicated pointer.

〔Example〕

An embodiment of the present invention will be described below with reference to the drawings. FIG. 1 is a block diagram of a computer according to an embodiment of the present invention. (1) is a pointer dedicated to software trap processing, (7) is a main memory device, (3) is a program counter that holds an address in the main memory device in which an instruction to be executed is stored, and (2) is a main memory device. A stack pointer indicating the highest position of the data stored in the storage device (7) in the last-in-first-out format, (4) at least one general-purpose or special-purpose register, and (5) of the computer. Control register, including control flags and status flags, (6a)
Is a control means. The main storage device (7) is provided with a stack area (8) for storing data in the last-in / first-out format, and the stack pointer (2) is set to the highest position of the data stored in this area. ) Is pointing. Further, the control means (6a) interprets an instruction fetched from a position on the main storage device (7) indicated by the program counter (3) and controls the execution of the instruction, and at the same time, the software trap processing dedicated pointer ( 1), a program counter (3), a stack pointer (2), a register (4), a control register (5), and a main memory device (7) are used for data transfer control.

The operation at the time of executing the software trap generation instruction in the computer of the above embodiment of the present invention will be described. FIG. 2 is a state diagram of the stack in the main memory before and after the execution of the software trap generation instruction of the computer. Just before executing the software trap generation instruction, the stack
The pointer (2) holds the stack position [S0] and, as shown by the arrow (9), indicates the highest position of the data accumulated in the stack area (8) by the execution of the program so far. pointing. The software trap processing dedicated pointer (1) holds the stack position of the information saved by the previous software trap generation instruction, as indicated by the arrow (11). When the software trap generation instruction is executed, the information including the contents of the software trap processing dedicated pointer (1) and the return address is transferred to the stack position [S0 + 1] of the stack area.
From the stack position [S1a] to the stack.
The contents of the pointer (2) and the pointer for software trap processing (1) are both indicated by arrows (10a) and (1).
As shown in 2), it is updated to the stack position [S1a]. That is, when the arrow (11) is the data saved in the stack memory when the first software trap generation instruction occurs, the arrow (12) indicates the second software
It is the data saved in the stack memory when the trap generation instruction is generated. Then, the start address of a specific program determined by each computer or operating system is stored in the program counter (3). Therefore, the next instruction is fetched from the main memory address stored in the program counter (3) and executed. The control described above is performed by the control means (6a).

The information stored between the stack position [S0 + 1] and the stack position [S1a] is the contents of the software trap processing dedicated pointer (1) and the program counter (3).
In addition to the contents (return address) of (1), the contents of the control register (5), the contents of the general-purpose or special-purpose register (4), specific data in the main memory, etc.

Also in this computer, the stack grows dynamically every time a program or a subroutine is called, and the contents of the stack pointer dynamically change accordingly. However, the pointer for software trap processing (1)
The contents of the, when the processing of the software trap is completed,
Alternatively, it does not change until another software trap generation instruction is newly executed. For example, when the program A calls the system program S by the software trap generation instruction and the called system program S calls the subroutine B, the stack changes as shown in FIG. Immediately before the execution of the software trap generation instruction, the software trap processing dedicated pointer (1) is saved in the main memory by the previous software trap generation instruction as indicated by the dashed arrow (40). The stack pointer (2) points to the stack position [SP0] as indicated by the solid arrow (30), but the stack pointer (2) points to the stack position of the stored information. When some information including the contents of the trap processing dedicated pointer (1) and the return address is stored in the area (21a) at the top of the stack, the software trap processing dedicated pointer (1) and the stack pointer Both (2) indicate the stack position [SP1a] as indicated by the solid arrow (41) and the broken arrow (31a). Further, if the area (22) is used for some purpose when the program S is executed, the stack pointer (2) has a broken arrow (32) immediately before the subroutine B is called from the system program S. ), And indicates the stack position [SP2]. Then, when subroutine B is called, some information including the return address is stored in the area (23) at the top of the stack, and the stack pointer (2) is indicated by the broken arrow (33).
The stack position [SP3] is pointed like. However, the contents of the software trap processing-dedicated pointer do not change until the software trap processing is completed or another software trap generation instruction is newly executed. For example, if a new software trap generation instruction is executed when subroutine B is executed,
That is, the arrow (12) is the data saved in the stack memory when the first software trap generation instruction is generated, and the software trap generation instruction newly executed when the subroutine B is executed is changed to the second software generation instruction. In this case, the contents including the contents of the software trap processing dedicated pointer (1) and the return address are saved in the stack as described above, and a new value is stored in the software trap processing dedicated pointer (1). . However, when the processing of this new software trap is completed, the previous state can be restored by restoring the contents of the saved software trap processing dedicated pointer (1) from the stack.

In this example, it is assumed that the execution of the subroutine B is controlled by the information of the program A saved in the area (21a) by the software trap generation instruction. For example, there may be a case where the area (21a) contains interrupt permission identification information and the interrupt permission for the interrupt request generated during the execution of the subroutine B is determined by this identification information. . In such cases,
If the position of the identification information in the information saved in the area (21a) is calculated from the content of the pointer (1) dedicated to software processing, the identification information can be referred to immediately. The format of the information saved when the software trap generation instruction is executed is unique to each computer, and the position of the identification information is always constant from the contents of the stack position pointed to by the software trap processing dedicated pointer (1). They are separated by the value of.
Therefore, not only when the identification information is referred to from the subroutine B, but also from any program or subroutine called directly or indirectly by the software trap generation instruction, another software trap is You can refer to it in the same way as long as it is not running.

In the above embodiment, the number of stack areas (8) and the stack pointers (2) in the main memory is one, but a plurality of stack areas and a plurality of stack pointers are provided. The software trap processing pointer (1) and other information are saved in different stacks, the stack is switched to another stack by a software trap generation instruction, and The dedicated stack for the trap processing dedicated pointer (1) may be realized by newly providing another storage device (for example, a register stack or a cache memory). In any case, the same effect as the above embodiment can be obtained.

〔The invention's effect〕

As described above, according to the present invention, in addition to the first holding means for holding the stack address indicating the latest stack completion position, the contents of which are updated when the program including the software trap generation instruction is called, the software trap is also added. Second holding means dedicated to the processing of the generated instruction and second when the second software trap generating instruction is generated during execution of the first software trap generating instruction.
By providing the control means for storing the address indicating the stack completion position in the second holding means, the second holding means, at an arbitrary time point, generates the last software trap generation instruction that is traced back from that time point. An address indicating the stack completion position at the time can be held.

Therefore, from the various programs called by the software trap generation instruction, the stack memory is stored in the stack memory when the software trap generation instruction that calls the program is generated based on the address indicating the stack completion position stored in the second holding unit. The saved data can be easily referenced.

[Brief description of drawings]

FIG. 1 is a block diagram of a computer according to an embodiment of the present invention, and FIG. 2 is a diagram showing a state change of a stack in a main memory before and after execution of a software trap generation instruction in the computer. Is the software of the computer
The figure which shows the change of the stack in the trap processing execution example,
FIG. 4 is a block diagram of a conventional computer having a software trap generation instruction, and FIG. 5 is a diagram showing a state change of a stack in a main memory before and after execution of a software trap generation instruction of the conventional computer. FIG. 6 is a diagram showing a stack change in a software trap processing execution example of a conventional computer. (1) is a pointer dedicated to software trap processing,
(7) is the main memory, (3) is the program counter,
(2) is a stack pointer, (4) is a general-purpose or dedicated register, (5) is a control register, and (6a) and (6).
b) is a control means. In the drawings, the same reference numerals indicate the same or corresponding parts.

 ─────────────────────────────────────────────────── ─── Continuation of the front page (56) Reference JP-A-59-94147 (JP, A) Transistor Technology, January 1982, January 1, 1982, CQ Publishing Co., Ltd. P. 248-251 , P .; 272-277

Claims (1)

(57) [Claims] 1. A first-in, first-out stack memory for temporarily storing data held in a register when a program call including a software trap generation instruction occurs, and for returning to a calling program at the time of program call. First holding means for updating and holding the stack address indicating the stack completion position of the stack memory in which the data including the return address of the above is saved, and the calling program only when the software trap generation instruction is generated. Second holding means for updating and holding the stack address indicating the stack completion position of the stack memory in which the data including the return address for returning to the above is saved, and during execution of the first software trap generation instruction. To the second
When the software trap generation instruction is generated, data including a return address for returning to the calling program and the first holding means stored in the second holding means.
And a control means for storing the second stack address indicating the stack completion position in the second holding means.