JPS62171034A - Subroutine link system - Google Patents

Abstract

PURPOSE:To obtain a link system which has the short link execution time, less memory capacity and a flexible linkage between a program and a subrou tine by permitting a subroutine number to introduce a linkage subroutine and to link subroutines, instead of a memory address. CONSTITUTION:For calling a system common subroutine sub3, an A program 1 is generated and compiled to generate an object module OM. The generated OM and a linkage subroutine library 6 are specified to link-edit, whereby a load module including the linkage subroutine 4a is generated. The name of the subroutine 4a is the same as that of a subroutine main body 3. The subrou tine 4a knows a subroutine number 9, refers to a jump table 7 with the value (n) as an index, obtains the load address of the subroutine main body 3, and jumps to it.

Description

DETAILED DESCRIPTION OF THE INVENTION [Field of Industrial Application] The present invention relates to a method for linking subroutines called from a plurality of programs, and particularly relates to a method for linking subroutines that takes a short link execution time and requires a small amount of memory.

[Prior Art] One of the conventional methods for linking subroutines is a static linking method in which a program that calls a subroutine is compiled and the programs are linked when creating a load module. A known example of this method is a compiler for the language 11 CJ+ of UNIX Corporation in the United States.

In this method, you create a subroutine and
The converted module is stored in a library file. On the other hand, the program that calls this subroutine first compiles the program to create an object module, and then link-edits the object module and the subroutine library to create a load module. In this case, the load module also includes the main body of the subroutine. As a result, if there are n programs that call the corresponding subroutine, the main body of the subroutine will exist in each of the n load modules. That is, according to the above method, there is a problem that a large disk capacity is required to store the load module of the program, and the memory capacity loaded when the program is executed also becomes large.

Other methods for subroutine linking include, for example, the dynamic linking method discussed in Hitachi's HITAC series, VO33 Supervisor Micro Manual (1980).

In this method, a subroutine is loaded at the point during program execution when a subroutine call is about to be made. The program execution sequence is as follows.

(1) Loading a subroutine (LOAD) (2) Calling a subroutine (3) Calling a subroutine (can be repeated any number of times) (
4) Delete subroutine (DELETE) In this case, 1
If n programs calling one subroutine are being executed, each load and erase must be issued once. However, when a load instruction is issued from a certain program, if another program has already loaded the corresponding subroutine, there is no need to load it again. However, when a subroutine deletion instruction is issued from a certain program, if another program is using the subroutine, the deletion operation must not actually be performed. It is not allowed to perform each operation independently; each time a loading or erasing instruction is issued, the O8 (operating system) must run to determine whether or not to load or erase and execute the associated processing. .

[Problems to be Solved by the Invention] When the above-described conventional static linking method is adopted, subroutine linking can be executed using virtually one instruction (
Since it is only necessary to execute a jump subroutine (JSR), processing can be performed at high speed.

However, since the substance of the subroutine is duplicated by the number of called programs, the disk capacity for storing it and the amount of memory required for executing the program increase. Furthermore, when changing the contents of a subroutine, it is necessary to relink it in all programs that call it, so the relationship between programs and subroutines becomes very "rigid."

On the other hand, when using the dynamic link method, only one subroutine entity is required in memory, so
Only a small amount of memory is required. Also.

Since the link between a program and a subroutine is done when the program is executed, as long as the name of the subroutine remains the same, even if the contents of the subroutine change,
There is no need to change or link-edit the calling program.

However, for each program, a load instruction must be issued to the calling program, and finally an erase instruction must be issued, and furthermore, the intervention of O8 is required to execute these instructions. In order to enter O8 from a user program and return to the user program again, it is necessary to execute several hundred steps of instructions in a typical O8 case. Therefore, the dynamic link method has the disadvantage that the linkage is 1 heavy. Another problem is that even if the dynamic link method is adopted, not all subroutines can be dynamically linked.

The problem lies in the fact that some static link methods are mixed.

For this reason, it is necessary for the subroutine caller to know whether the other party is a static link or a dynamic link and write the subroutine accordingly.

SUMMARY OF THE INVENTION An object of the present invention is to provide a subroutine linking method in which link execution time is short, the memory capacity for storing the subroutine body is small, and the connection between a program and a subroutine is "soft."

In other words, the present invention allows the contents of a subroutine to be changed without affecting the calling program.

Moreover, it provides a subroutine linking method in which the caller does not need to be aware of whether a subroutine is dynamically linked or statically linked.

[Means for Solving the Problems] In order to solve the above problems, the present invention employs two means. One of these is the introduction of a subroutine for linkage, and the other is to link with subroutines using subroutine numbers rather than memory addresses.

[Effect: The creator of a subroutine called by multiple programs determines a unique subroutine number when creating the subroutine. Additionally, a linkage subroutine is created in conjunction with this subroutine. The role of the linkage subroutine is to be statically linked with the calling program and to jump to the subroutine itself by drawing a jump table from within the program using the subroutine number as a key.

Loading a subroutine, that is, storing it in an executable form on memory, can be performed independently of the execution of a subroutine call. Therefore, if the subroutine number is not changed, there is no need to change the calling program even if the contents of the subroutine itself or the loading address of the subroutine in memory is changed.

However, in the latter case, only the contents of the jump table need to be rewritten.

[Example] Hereinafter, an example of the present invention will be described with reference to the drawings.

FIG. 1 is a diagram representing the basic concept of the present invention.

When creating subroutines common to multiple systems,
The creator creates a subroutine 3 and registers it in the subroutine library 5. At that time, the creator 1 also creates a linkage subroutine 4 and registers it in the linkage subroutine library 6. Furthermore, a subroutine number (n) unique to the subroutine 3 is determined, and its location in the system space, that is, at which address it is placed, is determined. The subroutine name, subroutine number, address, size, etc. are stored in the subroutine management file 8.

The above subroutine is loaded at an appropriate time after system startup until the program calls it. That is, the contents of the subroutine library 5 are copied starting from a predetermined address in the system space while referring to the subroutine management file 8, and at the same time, the address of the subroutine is written in the jump table 7 in correspondence with the subroutine number.

Next, the case of calling a subroutine will be explained. Here, multiple programs (for example, programs 1 and B)
If programs 2) are running in independent user virtual spaces and sharing the system space, in other words, the system space looks like the same address from every program, system common subroutines (names Let us consider one program (for example, program A) that calls 3 (let's say sub).

First, program A is created and compiled to create an object module.

By specifying the object module created in this way and the linkage subroutine library 6, and performing link editing 1~, the linkage subroutine 4a
Create load module 1 that includes. Here, the name of the linkage subroutine is the same as that of the subroutine body 3. In Figure 1, for convenience of explanation, the names of both parties are s.
They are distinguished as ub and sub'. In the actual load module, only the linkage subroutine is linked, but from the perspective of the calling program, it is indistinguishable from the case where the subroutine itself is linked.

The linkage subroutine 4a knows the subroutine number 9 (the value is n), looks up the jump table 7 using n as an index, finds the load address of the subroutine body, and jumps there.

An example of a linkage subroutine program is shown in FIG. The first line (Ll) defines the subroutine number, which is 10 in this example. The second line (L2) calculates the address of the jump table, and indicates that the address is the start address (JUMPTABLE) of the jump table plus the subroutine number multiplied by 4, and stores it in the aO register. The third line (L3) is an error check, and it is determined whether the content of the jump address is IIO#t. If “0”, the 4th line (L/-4)
The process branches to line 7 (Ll) from the judgment statement. The content of the jump address is 710", which means
This means that the subroutine corresponding to that subroutine number has not been registered.

Assign “-1” to the dO register on the 8th line (L8),
Then, on the 9th line (L9), the process returns to the calling side. 8th line (L8)
The value set in the do register in step 1 can be seen as the return value of the subroutine on the side that called the subroutine, so it is possible to determine whether an error has occurred based on the call value.

In the fifth line (L5), after putting the contents of the jump table, that is, the storage address of the subroutine into the aO register, the aO
Jump to the address pointed to by the register. This results in
Can be linked to the subroutine body. In the last part of the subroutine body, the same rts instruction (re
(turn from subroutine) returns control to the program that directly called the subroutine.

Next, addition, deletion, and modification of system common subroutines will be explained with reference to FIG. 1 again.

When adding a subroutine, a subroutine body and a linkage subroutine are created and added to the respective libraries 5 and 6. At that time, the subroutine number, storage address, etc. may be written in the management file 8, and the address may be written in the area corresponding to the subroutine number in the jump table 7.

In the case of deletion, contrary to the case of addition, it is only necessary to delete the corresponding entries from each of the subroutine library, linkage subroutine library, management file, and jump table. In this case, the linkage subroutine is linked to the program that calls the subroutine, and the subroutine number is known, so
When you run the program, not-f as explained in Figure 2 will be displayed.
An ound error occurs.

In the case of a change, the subroutine is re-created and re-registered in the subroutine library 5. On this occasion.

If the size of the subroutine is smaller than the previous size, there is no need to change the loading address, so only the size of the management file 8 is changed. If the size after change is larger than the size before change, it is necessary to change the load address of the subroutine. In this case, 1. The address and size in the management file 8 and the jump table 7 are rewritten.

As explained above, as long as the subroutine number does not change, even if you change the contents of the subroutine or change the loading address, you cannot rewrite or recompile the calling program.

No need to relink edit.

[Effects of the Invention] According to the present invention, the amount of memory required is smaller than that of the static link method, and since the program loads the subroutine into memory before calling it, the program loads the subroutine when executing the subroutine call. The time required for link execution is shorter than in the dynamic link method, in which a determination is made as to whether or not the link is present, and a load process is performed each time depending on the determination result. Furthermore, even if the contents of a subroutine or the loading address are changed, it has the flexibility of not affecting the program that calls the subroutine.

[Brief explanation of drawings]

FIG. 1 is a diagram for explaining the basic concept of the present invention, and FIG. 2 is a diagram showing an example of a linkage subroutine program. 1...A program, 2...B program, 3...
・Subroutine, 4... Linkage subroutine,
5... Subroutine library, 6... Subroutine library for linkage, 7... Jump table, 8... Management file, 9... Subroutine number 7th corner]'

Claims (1)

[Claims] 1. A step of registering a subroutine to which a unique subroutine number has been assigned in a first library; a step of registering a linkage subroutine that is paired with the above subroutine in a second library; and the above subroutine. loading from a first library into a memory space; creating a jump table in a predetermined area of the memory space that indicates the correspondence between the load address of the subroutine and the subroutine number; and a program that uses the subroutine. and a step of linking and editing the linkage subroutine in the second library to create a load module, and referring to the jump table in the process of executing the linkage subroutine in the load module. A subroutine link method characterized in that a jump to a corresponding subroutine is performed. 2. The subroutine and the linkage subroutine paired therewith have the same subroutine name, and the program specifies a jump to the subroutine using the subroutine name. Subroutine link method.