JPH03191426A - Data processor - Google Patents

Abstract

PURPOSE:To allow a CPU to automatically determine an area for storing the function of an argument and the result of a function at the time of accessing, and restoring the function by providing the data processor with 1st and 2nd stack registers for controlling a stack tag memory and so on. CONSTITUTION:The pointers of variables A, B are inputted to a function stack memory 6. When an instruction CALLT func3 is executed, a return pointer from the func3 is inputted to the memory 6 and operation is jumped to the entry of a program code of the function func3. After executing the func3, the function result is stored in an area specified by the contents SSD:SPd of a data stack register 2b in a data stack memory 7 and then the contents SSD:SPd of the register 2b are updated. The pointer of the area storing the function result of the func3 is set up the position of the memory in which the 1st argu ment of the func3 is set up and the contents SSf:SPf of the function stack register 2a are updated. In order to indicate the setting of the pointer in the memory 7 to the memory 6, the corresponding set position of a stack tag mem ory 8 is turned on. The operation is restored from the func3 to complete the instruction CALLT func3.

Description

[Detailed description of the invention] [Industrial application field]

The second invention relates to a data processing device that performs stack control for high-level languages.

[Conventional technology]

FIG. 5 is a block diagram showing the configuration of a conventional data processing device. In the figure, 1 is a central processing unit (hereinafter referred to as CPU) that performs various calculations and controls, and 2 is the CPU.
I is a stack register for storing the used position in the stack memory, 3 is a code data memory for storing program codes and data necessary for various operations of the CPU, and 4 is a read point L I F by the stack register 2. O(last-in first-o
This is a stack memory that stores argument data and program local data when program code is executed. Next, the operation will be explained. Here, the high-level language level source program executed by the CPU is shown in FIG. 7(a), and the symbol @A indicates a pointer that stores the data of variable A. Also, assume that each function has the following input/output relationship. ■Func l Crab 4 pointer human power. Three of the pointers are pointers that have input data of func 1, and the remaining one pointer specifies the location where the results obtained by inputting the three pointers are returned. Returns the result of the operation by funcl to the location specified by the pointer that returns the output result. The operation result is also returned to the variable pointer of the first argument. ■func Three crabs and two pointers. One point in
unc 4 is a pointer that specifies where to return the result. The result of func3 or func4 is returned to the location specified by the pointer that returns the output result, and the pointer is returned as the result of the typed function. For example, the pointer that is the output of the typed function func 3 is input as is as the first and second arguments of func 2 . ■func 2 It has the same input/output relationship as func 3, func 4, etc. except that the number of arguments is three. In addition, the pointer that returns the result shown as rLQA (XXX)J in FIG. 7(a) is called a virtual register 5. As shown in FIG. 6, this virtual register 5 is composed of a plurality of registers having an arbitrary maximum size of n bytes for storing results in various formats, and is used as a function result storage area. This is because if a function is reentrant, the local data within this function will be released after returning from the function, so it is necessary to hold it in this virtual register. Furthermore, the reason why the position where the result of the function is returned is input as a pointer, such as r@LQA (0)J, is to set the data size for storing the result of the function to an arbitrary maximum value of n bytes. Using the source program as described above, the program code actually executed by the CPU 1 is generated as shown in FIG. 7 by language processing using a compiler or the like. Next, the operation of the stack memory 4 when executing the program code shown in FIG. 7(b) will be explained using FIGS. 8 and 9. First, it is assumed that a stack segment (hereinafter referred to as SS) and a stack pointer (hereinafter referred to as SP) constituting the stack register 2 have been initialized to predetermined values P and Q. The first line command P IJ S H@A stores the pointer to the variable in the stack memory 40P:Q location, and SP
, is updated to SP. The program code (
Stack memory 4 executed up to the 3rd line in Figure 7(b))
The state of is shown in FIG. 8, and the stack register 2 is SS:S.
It will point to P3 (and will be stored in the virtual memory 5 at the same time). Furthermore, execute the instruction CALLfunc3 on the fourth line,
Immediately after entering the function, the state of the stack memory 4 becomes the state shown in (a) in FIG. 9, and the return pointer of the function func 3 is stored in the stack memory 4.
When func 3 is executed and ret (returns) from this function, the state of the stack memory 4 is 0)) in the same figure, and @B, which is stored on the stack memory 4 as an argument for func S, @LQA (0) is released and stack register 2 points to SS:SP. Next, the result of func 3 becomes the argument of the next number furrc2, so in the 5th line, the result of func 3 is stored in the stack memory 4, and at the same time, the stack register 2 is set to SS:
Update to SPz. In this way, the func 3 function is evaluated first, but from the 6th line to the final 188th line of the program code, it is evaluated in the same manner as func 3, and finally the result executed by func 1 is is stored in @LQA(0) of the virtual register 5, and all SS is released and returned to the original value SS:SPO(P:Q).

[Problem to be solved by the invention]

Since conventional data processing devices are configured as described above, it is necessary to determine at the source program level the locations in the virtual registers required to return the result of a function.
The source programs themselves become complex, and language processing such as language conversion for automatically generating these source programs also becomes complex. In addition, the size of the generated program code becomes large and the execution speed becomes slow. This invention was made to solve the above-mentioned problems.
An object of the present invention is to obtain a data processing device that can automatically determine a PU.

[Means to solve the problem]

The data processing device according to the present invention includes a function stack memory that stores argument data and program local data necessary when executing a program code stored in a code data memory, and a function stack memory that stores the execution results (function results) of this program code. a data stack memory to store; a stack tag memory to store existence information of a pointer to the data stack memory to store execution results returned to the function stack memory; and a stack tag memory to manage the function stack memory and the data stack memory. It is equipped with a first and a second stack register.

[Effect]

The data processing device according to the present invention includes a function stack memory that stores argument data and program local data necessary when executing a program code.
Contains information as to whether a pointer instruction to a data stack memory provided in place of conventional virtual memory for returning execution results is stored, and information for releasing the data stack memory upon return from a function. Since we have provided a stack tag memory to be used as The result storage area can be determined.

[Embodiments of the invention]

An embodiment of the present invention will be described below with reference to the drawings. FIG. 1 is a block diagram showing the configuration of a data processing device according to an embodiment of the present invention, and the same or equivalent parts as in the conventional data processing device (FIG. 5) are given the same reference numerals and explanations are omitted. do. In the figure, 2a is a function stack register (stack segment is S
Sf, stack pointer is SPf), 2b is a data stack register as a second stack register indicating the used position in the data stack memory 7 (stack segment is SSd, stack pointer is SPd)
, 6 is a function stack memory that stores argument data and program local data necessary for executing the program code stored in the code data memory 3; 7 is a data stack memory that stores the function result of the program code; 8 is a stack tag memory having information on how many pointers to the data stack memory 7 for returning function results are present in the function stack memory 6. FIG. 2 is a diagram explaining the relationship between the function stack memory 6 and the stack tag memory 8. The stack tag memory 8 is one of the function stack memories 6.
Each word has one bit of information, and if a pointer pointing to the data stack register 2d is stored in the function stack memory 6, the bit corresponding to the memory pointer is turned ON. Next, the operation will be explained. Here, the high-level language level source program executed by the CPU is shown in FIG. 3(a). Although this source program corresponds to the source program shown in FIG. 7(a), there is no pointer specification for returning the function result. Further, the symbol @A indicates a pointer for storing data in a variable, and each function is assumed to have the following input/output relationship. ■func 1 person 3 pointers input/output Returns the calculation result to the location specified by the variable pointer of the first argument. ■func Returns the two pointer input/output operation results into the data stack memory specified by SSd:SPd. ■func 3 people 1 crab pointer input func 4
The output calculation result is returned to the data stack memory specified by SSd: SPd. Note that the func 2+ func 3. func
4 is a typed function that returns a pointer, and func 1 is an untyped function that returns nothing. From such a source program, the program code actually executed by the CPUI is generated by language processing by a compiler or the like as shown in FIG. 3(b). Next, the operations of the function stack memory 6, data stack memory 7, stack tag memory 8, and two stack registers 2a and 2b when executing the program code shown in FIG. I will explain. The states of each memory 6°7.8 and registers 2a and 2b immediately after executing the 1st to 3rd lines of this program code are shown in (a) and (b) in Figure 4. The operation up to the 3rd line is It will look like this: ■ Put the pointers of variables A and B into the function stack memory 6. ■ By executing the instruction CAL LT func 3, the return pointer from CAL LT funC3 is placed in the function stack memory 6, and the function func
c Jump to the program code entry in 3. ■ After executing func 3, the function result is stored in the data stack register 2b contents SS of the data stack memory 7.
d: Store in the area specified by SPd, and update the contents of the data stack register 2b SSd: SPd. ■ The pointer (Φ) to the area where the function result of func 3 is stored is @LQA (0)), and the function stack memory 6 where the first argument of func 3 is set.
(the area where @B is set) and the contents SSf of the function stack register 2a.
: Update SPf. ■ To indicate that the pointer (@LQA (0)) to the data stack memory 7 has been set in the function stack memory 6, the corresponding set position in the stack tag memory 8 is turned ON. ■ Return from func 3 and execute the command CA L L T
Complete func3. The 4th and 5th lines of the program code are executed in the same way, and the state changes from state (C) to state (d) in FIG.
A pointer indicating the function result of nc 3 will be stored. In the 6th line of the program code, (e) in Figure 4
The state changes from the state to the state (f). This state (e)
In, function func 2 is data stack memo + J
The calculation is performed using two argument data (@LQA(0), @LQA(1)) existing on 7. From the information in the stack tag memory 8, it can be seen that when function func 2 is completed, one function result data area on the data stack memory 7 only needs to exist, so the register 2b of the data stack is placed in the position indicated by Content SSd: S
Pd is updated. In this way, by executing up to the 8th line of the program code, each memory 6.7.8 and registers 2a, 2
The state of b changes from (□□□ to (c). The program code on the 9th line is an instruction CALLN, unlike the other instructions CALLT. This CALLN is used when the function result is obtained. Later, it will be shown that unlike the instruction CALLT, this is a function call that does not store the result pointer on the function stack memory 6.In the case of the instruction CALLT, as explained in each state (a) to (c),
The function result is stored on the function stack memory 6 after the function operation. 9th line instruction CALLN fun
Upon completion of c1 execution, all the function stack memory 6, data stack memory 7, and stack tag memory 8 return to their original states as shown in state (i) in FIG. In the above embodiment, the function stack memory 6, the data stack memory 7, and the stack tag memory 8
Although these are different memories, each memory area may exist independently on the same memory. In addition, in FIG. 4, the size (n bytes) of one function result data storage area of the data stack memory 7 is:
It may also be possible to change and set it by program code. Also, FRET is used as the return program code from the function.
URN (SIZE.@Data) Here, s+zE: Size data of function stack memory 6 to be released when function returns: Data: Pointer to function operation result stored in data stack memory 7 A microcode is prepared and used in the example. The function return process described above may also be performed.

【Effect of the invention】

As described above, according to the present invention, when a function is called and returned, the area for storing function arguments and function results is stored in the CPU.
Since the configuration is configured so that the area to be used can be automatically determined, there is no need to determine the area to be used when generating the source program, and coding becomes easy.If there is a tool for generating these source programs, the source generation process becomes easy. Furthermore, since the program is simplified, it has the effect of improving both capacity and speed.

[Brief explanation of drawings]

FIG. 1 is a block diagram showing the configuration of a data processing device according to an embodiment of the present invention, FIG. 2 is a diagram showing the relationship between the function stack memory and the stack tag memory in the present invention, and FIG. 3 is a data processing apparatus according to the present invention. A diagram showing an example of a source program and a program code executed by a processing device, FIG. 4 is a diagram showing each memory state in this invention when the program code of FIG. 3(b) is executed, and FIG. Block diagram showing the configuration of the data processing device, No. 6
The figure shows the configuration of virtual memory, Figure 7 shows an example of a source program and program code executed by a conventional data processing device, and Figures 8 and 9 execute the program code shown in Figure 7, etc. FIG. 2 is a diagram showing the state of a stack memory in a conventional data processing device when processing. In the figure, ■ is the CPU, 2a is the function stack register, 2b is the data stack register, 3 is the code data memory, 6 is the function stack memory,
7 is a data stack memory, and 8 is a stack tag memory. In addition, in the figures, the same reference numerals indicate the same or equivalent parts. 2b: Tenes' Messoregi χ'not) H) 1 [cl dl Figure (Yol) Figure (0) ALL func 1 (@A func 2 (func3 (@B). func3 (@C1). func 4 (@D)) bl Figure (2 of spears) el fl (9) +h1 1'Ll Figure 5 (b) func 41@D. @LQA lot l.

Claims (1)

[Claims] A code data memory that stores program codes and data necessary for various operations in the central processing unit, and stores necessary argument data and program local data when executing the program code stored in the code data memory. a function stack memory; a data stack memory that stores the execution result of the program code; a stack tag memory that stores existence information of a pointer instruction to the data stack memory that stores the execution result returned to the function stack memory; A data processing device comprising first and second stack registers each indicating a used position within a stack memory and a data stack memory.