JP3520966B2 - Information processing equipment - Google Patents

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to an information processing apparatus, and is particularly suitable for application to a function calling system having an instance.

[0002]

2. Description of the Related Art Some conventional operation control devices such as sequencers and microcomputers operate with a program written in a language system capable of processing a function having an instance. As such a language system, for example,
There is a controller language defined in "IEC1131-3", and the function block (F
B) corresponds to a function having an instance memory.

FIG. 5 is an example of machine language expansion showing a conventional function calling method. Here, it is assumed that the function funcA and the function funcB each have their own instance. An instance is a memory area that is fixed when the function executes, and stores the previous processing value. It should be noted that even if the same function is used, if the position where the function is called is different, the storage position of the instance also differs.

In FIG. 5, when calling the function funcA, the main function MAIN sets the instance start address of the function funcA in an address register in the processor and calls the function funcA. Then the function f
If uncA calls the function funcB, the function fun
Since the instance start address of cA is set in the address register in the processor, the function funcA
After saving the instance start address of () to the stack (), set the instance start address of the function funcB to the address register in the processor (),
Call the function funcB. Next, when the processing of the function funcB ends and the processing of the function funcA returns, the function f
The instance start address of uncA must be set in the address register in the processor. Therefore, the instance start address of the function funcA saved in the stack is set in the address register in the processor (), and the process returns to the function funcA.

FIG. 6 is an example of machine language expansion showing a conventional function calling method when the same function is called at a plurality of points. In the example of FIG. 6, the main function MAIN is the function fun.
If cA is called at two places and the position called by the main function MAIN of the function funcA is different, the function fun
The storage location of the cA instance is also different. Therefore, two objects of the function funcA1 and the function funcA2 are generated.

In FIG. 6, the main function MAIN is L
When calling the function funcA at the position of 1, the function func
The instance start address of cA1 is set in the address register in the processor, and the function funcA1 is called. Next, when the function funcA1 calls the function funcB, the instance start address of the function funcA1 is saved in the stack because the instance start address of the function funcA1 is set in the address register in the processor, and then the instance start address of the function funcB1 is saved. The address is set in the address register in the processor and the function funcB is called. Then the function f
When the processing of uncB is completed and the processing returns to the processing of the function funcA1, the instance start address of the function funcA1 needs to be set in the address register in the processor. Therefore, the instance start address of the function funcA1 saved on the stack is set in the address register in the processor, and the process returns to the function funcA.

Next, when calling the function funcA at the position of L2, the main function MAIN sets the instance start address of the function funcA2 in the address register in the processor and calls the function funcA2. Next, when the function funcA2 calls the function funcB, the instance start address of the function funcA2 is saved in the stack because the instance start address of the function funcA2 is set in the address register in the processor, and then the instance start address of the function funcB2 is saved. The address is set in the address register in the processor and the function funcB is called. Then the function fu
When the process of ncB ends and the process returns to the process of the function funcA2, the instance start address of the function funcA2 needs to be set in the address register in the processor. Therefore, the function f saved in the stack
The instance start address of uncA2 is set in the address register in the processor, and the process returns to the function funcA.

[0008]

However, in the function calling method shown in FIG. 5, the function fun having an instance is used.
When calling the function funcB having an instance from cA, the instance start address of the function funcA is saved in the stack of the address register, and the function funcB is saved.
The instance start address of the function funcA needs to be set in the address register, and when returning to the process of the function funcA, the instance start address of the function funcA needs to be set again in the address register, and the program that executes these processes is There was a problem that it became complicated.

Further, in the function calling method of FIG. 6, when the function funcA is used at a plurality of places, the function fu
ncA has a separate instance for each call position, and the function funcB called from the function funcA also has its own instance for each function funcA. Therefore, even if the same function funcA is called, a machine word is generated that sets the number of objects of the function funcA called and sets the instance start address of the function funcB called by each function funcA in the address register. There was a problem that I had to do.

Therefore, an object of the present invention is to provide an information processing apparatus capable of simplifying a program for calling a function having an instance.

[0011]

In order to solve the above-mentioned problems, according to the present invention, in an information processing apparatus for processing a function having an instance, an information processing apparatus having a stack is provided.
The first register with the dress register and the first one machine language instruction.
The start address of the instance depending on the call position of the number
Saved on the stack and set it to the calling position of the second function.
The start address of the instance according to the address register
And a second one machine language instruction,
First add of instance depending on the call position of function 1
Of the address register from the stack
In the first function among the means for setting
Before setting in the address register with one machine language instruction
The beginning of the instance depending on the call position of the second function
The second function and the second
Of calling an instance depending on the call position of the function
Equipped with steps.

As a result, it becomes possible to simplify the program for calling the function having the instance, and by executing these instructions directly in the hardware, the calling process of the function having the instance is executed at high speed. It becomes possible.

According to one aspect of the present invention, the second
Address of the instance depending on the call position of the function
Instance according to the call position of the first function
It is characterized by comprising means for setting to. With these features, even if the same function is used at multiple points, it is not necessary to individually generate the object of the function at each point, which makes it efficient to call a function that has an instance. It becomes possible to do it.

[0014]

DETAILED DESCRIPTION OF THE INVENTION An information processing apparatus according to 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 an information processing apparatus according to an embodiment of the present invention. In FIG. 1, the CPU 1 has
A fetch control unit 5, a data memory access control unit 6, and an operation execution unit 8 are provided, and the data memory access control unit 6 is provided with an address register unit 7 having a stack structure.

The data memory 3 includes an instance memory 4
Is provided, and the instance of the function is mapped in the instance memory 4. In addition, even if it is the same function,
If the call position of the function is different, the storage position of the instance is also different.

The fetch control unit 5 includes a program memory 2
The instruction is fetched from and is supplied to the operation execution unit 8. The data memory access control unit 6 takes out the data from the data memory 3 and supplies it to the operation executing unit 8.

The operation execution unit 8 processes the data sent from the data memory access control unit 6 according to the instruction sent from the fetch control unit 5. When calling a function,
The start address of the instance memory 4 of the function is set in the address register unit 7, and when accessing the instance memory 4 in the function, the address register unit 7
Is used as a base register to access the instance memory 4.

When function B is called from function A,
The start address of the instance 4a of the function A is saved in the stack of the address register unit 7, and the start address of the instance 4b of the function B is set in the address register unit 7. When the function B returns to the function A, the function A
The instance 4a of the function A is fetched from the stack of the address register unit 7
The head address of a is written back to the address register unit 7.

Further, as a pre-process at the time of starting the program, the start address of the area of the instance 4b of the function B called from the function A is set in advance in the area of the instance 4a of the function A.

FIG. 2 is a diagram showing an example of a program showing a function calling method according to an embodiment of the present invention and contents of an instance memory. In FIG. 2, the main function ma
In order to call the function funcA at the position of in, P
The USH_IS100 instruction is used. Further, the PUSH_IS140 instruction is used to call the function funcA at the position of the main function main.
In the function funcA, the functions funcA to func
A PUSH_IS (IS + 0) instruction is used to call B. In the function funcB, the function func
In order to return from B to the function funcA, POP_IS
The instruction is being used.

The function funcA called at the position of
Data memory 3 as an area of the instance memory 4 of
Nos. 100 to 119 are allocated, and 120 to 13 of the data memory 3 are set as the area of the instance memory 4 of the function funcB called from the function funcA at the position of
Function fun is assigned at address 9 and is called at position
The addresses 140 to 159 of the data memory 3 are allocated as the area of the instance memory 4 of cA, and the area of the instance memory 4 of the function funcB called from the function funcA at the position of 160 to 159 of the data memory 3 is allocated.
Address 179 is assigned.

Here, the function func called at the position of
In the area (100 address) of the instance memory 4 of A,
Function funcB called from function funcA at position
Start address of the area of instance memory 4 (120
Address), and the area of the instance memory 4 of the function funcA called at position (address 140) stores the top address (address 160) of the area of the instance memory 4 of function funcB called from the function funcA at position of Keep it.

PUS used in main function main
The H_IS instruction saves the start address of the instance of the function currently being processed in the stack of the address register unit 7, and sets the start address of the instance of the function to be called in the address register unit 7.

For example, in the PUSH_IS100 instruction, the start address of the instance of the function currently being processed is saved in the stack of the address register unit 7, and the start address (address 100) of the instance memory of the function funcA called at the position Set in part 7. Also, the PUSH_IS140 instruction saves the start address of the instance of the function currently being processed in the stack of the address register unit 7, and sets the start address (address 140) of the instance memory of the function funcA to be called at the position to the address register unit 7. set.

PUSH_ used in the function funcA
The IS (IS + 0) instruction saves the start address of the instance of the function currently being processed in the stack of the address register unit 7, and (IS + 0) in the instance memory 4
The data stored in the address is set in the address register unit 7. Here, IS is the start address of the instance of the function currently being processed.

For example, PUSH_ of the main function main
The IS100 instruction is executed, and the function funcA is executed at the position of
Is called, then PUSH_IS (IS
When the +0) instruction is executed, the start address (address 100) of the instance memory of the function funcA set in the address register unit 7 is saved in the stack of the address register unit 7. And the data stored at address 100 in instance memory (address 120)
Is set in the address register unit 7 and the function funcB is called.

Also, PUSH_I of the main function main
After the S140 instruction is executed and the function funcA is called at the position of, the PUSH_IS (IS +
0) When the instruction is executed, the start address (140th address) of the instance memory of the function funcA set in the address register unit 7 is set to the address register unit 7
To the stack. Then, the data (address 160) stored at address 140 of the instance memory is set in the address register unit 7, and the function funcB is called.

As a result, when the function funcA at the position of is called from the function funcB, the start address is 1
It becomes possible to perform processing using the instance of the function funcB at address 20, and the function fu at the position of
When the function funcB is called from ncA, it becomes possible to perform processing using the instance of the function funcB whose start address is 160, and the same function func
Even when the function funcB is called from cA at a different position, depending on the calling position of the function funcA,
It becomes possible to properly use the instance of the function funcB.

POP_I used in function funcB
The S instruction is the function funcA that calls the function funcB.
The start address of the instance of
Of the PUSH_IS instruction and the POP_IS instruction.
The program can be operated simply by executing the calling process of the function having the instance using the instruction.

The function f called from the function funcA
By storing the starting address of the area of the instance memory 4 of uncB in the area of the instance memory 4 of the function funcA, and specifying the starting address of the instance memory 4 of the function funcB using the PUSH_IS (IS + 0) instruction, It is not necessary to directly specify the start address of the instance memory 4 of the function funcB in the function funcA. For this reason, the function funcB generated separately corresponding to the respective positions of and
It is not necessary to separately generate the object of the function funcA for each instance of, and it is possible to efficiently perform the calling process of the function having the instance.

FIG. 3 is a block diagram showing a hardware configuration example for realizing the processing of FIG. In FIG. 3, the processor 11 is provided with a fetch controller 14, a fetch data storage register 15, a microprogram controller 16, a data access controller 17, an IS register 18, an IS register stack pointer 19 and an adder / subtractor 20. The control unit 14 fetches the instruction from the program memory 12 and stores it in the fetch data storage register 15.

In the data memory 13, for example, the instance memory area of FIG. 2 has the functions funcA and funcB.
It is provided for each calling position. Further, the start address of the instance memory of the called function funcB is stored in the area of the instance memory of the calling function funcA.

The data access control unit 17 reads and writes data in the data memory 13, and the IS register 18 stores the start address of the instance of the function currently being processed.

The microprogram control unit 16 uses the PUS
When executing the H_IS instruction, the contents of the IS register 18 are saved in the IS register stack pointer 19 and the adder / subtractor 20 increments the IS register stack pointer 19 by one, and then the start address of the instance of the function to be called is set in the IS register. Set to 18.

Further, the micro program control section 16 is
When executing the POP_IS instruction, the start address of the caller function instance is fetched from the IS register stack pointer 19 and set in the IS register 18, and the IS register stack pointer 19 is added to the adder / subtractor 20.
Decrement by 1.

Further, the micro program control section 16 is
When executing the PUSH_IS (IS + 0) instruction, IS
The contents of register 18 are set to IS register stack pointer 1
The IS register stack pointer 19 is incremented by 1 by the adder / subtractor 20. Then, the data access control unit 17 is instructed to read the data stored in the (IS + 0) address of the data memory 13. Note that IS indicates the start address of the instance of the caller function, and (IS + (IS +
The address 0) stores the start address of the instance of the called function. Data access control unit 17
Reads out the data stored in the address (IS + 0) of the data memory 13, the data is stored in the IS register 1
Set to 8.

FIG. 4 is a flowchart showing a function calling method according to an embodiment of the present invention. Note that these processes can be executed by a microprogram. In FIG. 4, when the PUSH_IS100 instruction is executed, the contents of the IS register 18 are stored in the IS register stack pointer 19 (step S1), the contents of the IS register stack pointer 19 are incremented by 1 (step S2), and the IS register 100 is set to 18 (step S3).

When the POP_IS instruction is executed, the contents of the IS register stack pointer 19 are changed to the IS register 18
(Step S11), the contents of the IS register stack pointer 19 are decremented by 1 (step S11).
S12 ).

When the PUSH_IS (IS + 0) instruction is executed, the contents of the IS register 18 are stored in the IS register stack pointer 19 (step S21), the contents of the IS register stack pointer 19 are incremented by 1 (step S22 ), In IS register 18 (IS +
Data of address 0) is set (step S23). Applicant's name change notification has been submitted as of November 6, 2003

[0040]

As described above, according to the present invention,
An instruction that saves the start address of the first instance in the stack and sets the start address of the second instance in the address register, and an instruction that extracts the start address of the first instance from the stack and sets it in the address register By using, it is possible to simplify the calling program of the function that has an instance, and by executing these instructions directly in the hardware, the calling process of the function that has an instance can be executed at high speed. It will be possible.

Further, according to one aspect of the present invention, even when the same function is used in a plurality of places by setting the start address of the instance of the function of the call destination to the instance of the function of the call source , It is not necessary to individually generate the object of the function for each location, and it becomes possible to efficiently perform the calling process of the function having the instance.

[Brief description of drawings]

FIG. 1 is a block diagram showing a configuration of an information processing apparatus according to an embodiment of the present invention.

FIG. 2 is a diagram showing an example of a program showing a function calling method and contents of an instance memory according to an embodiment of the present invention.

3 is a block diagram showing a specific configuration example of the information processing apparatus of FIG.

FIG. 4 is a flowchart showing a function calling method according to an embodiment of the present invention.

FIG. 5 is a program example showing a conventional function calling method.

FIG. 6 is a program example showing a conventional function calling method in the case of calling the same function at a plurality of points.

[Explanation of symbols]

1 CPU 2,12 Program memory 3, 13 data memory 4 instance memory 5, 14 Fetch controller 6 Data memory access controller 7 Address register section 8 Operation execution unit 11 processors 15 Fetch data storage register 16 Micro program controller 17 Data access control unit 18 IS register 19 IS register stack pointer 20 adder / subtractor

─────────────────────────────────────────────────── ─── Continuation of the front page (56) References JP-A-10-91443 (JP, A) JP-A-59-135551 (JP, A) (58) Fields investigated (Int.Cl. ⁷ , DB name) G06F 9/40-9/42

Claims (2)

(57) [Claims] 1. An information processing device for processing a function having an instance, wherein an address register having a stack and a first one machine language instruction are used to call a first function.
According to the head address of the instance is saved to the stack, and means for setting a start address of an instance by calling the position of the second function to the address register, the second one machine language instruction, the call to the first function Rank
Means for fetching the start address of the instance from the stack from the stack and setting it in the address register; and in the first function, the first one machine language instruction
Calling the second function set in the address register
Start address of the instance and call order depending on the position
The second function and the call position of the second function
An information processing device, comprising means for calling an instance according to . 2. A previous SL call to the first function start address Lee <br/> instance by calling the position of the second function
The information processing apparatus according to claim 1, further comprising means for setting an instance according to a position .