JP2003076558A - Method and program for controlling program execution - Google Patents

Abstract

PROBLEM TO BE SOLVED: To facilitate replacement of native codes in a system that directly executes a native code in place of part of an intermediate code not through an interpreter on an OS without having a dynamic link library function. SOLUTION: The native codes and first and second interface tables 600, 700 are loaded in a native code reservation area in a memory and after that, an operation of the interpreter is started. The table 600 stores information for calling the native code 110 from the interpreter 120 and the table 700 stores information for calling a library function intrinsic to the interpreter or the interpreter. When the native codes are replaced, the table 600 is also replaced with an updated table. In addition, storage positions of the tables 600, 700 are fixed positions.

Description

Detailed Description of the Invention

[0001]

The present invention is obtained by compiling an intermediate code part obtained by compiling a part of a source program and another part of the source program,
The present invention relates to a program execution control method including a plurality of nativeized program parts directly executed by a computer without passing through an interpreter, and a program execution control program for such a program.

[0002]

2. Description of the Related Art With respect to compiling and executing a source program, the source program is compiled into intermediate code so that the same source program can be executed on a computer having a different architecture.
A method is adopted in which the obtained intermediate code is interpreted and executed by an interpreter prepared for each computer. That is, each of a plurality of instructions included in the intermediate code is sequentially interpreted by an interpreter, the intermediate code is sequentially converted into a native code that is a machine language instruction that can be executed on a computer in use, and then executed.

However, in the program execution control method using such an interpreter, since the intermediate code is sequentially interpreted and executed, it takes time to execute the intermediate code.
Therefore, the part of the source program whose execution time you want to shorten, that is, the part of the intermediate code that you want to speed up, is converted into native object code (hereinafter sometimes referred to as native code) in advance, and the part of the intermediate code above is converted. Alternatively, a method of executing native code may be adopted.

[0004]

When a program consisting of such a combination of intermediate code and native code is used, the execution speed of the program is faster than when the native code is not used, but on the contrary, some problems occur. . For example, under a real-time operating system (real-time OS) generally used in the field of microcomputer systems, when it is desired to replace a native code with a new native code, for example, an improved native code, the native code is replaced. There is a problem that replacement of native code is not easy because of this.

That is, in order to make a set of native code and intermediate code executable by the interpreter,
You need to be able to call native code by the interpreter. In general, when the OS provides a dynamic link library as a tool for dynamically linking different program units, even if any program is updated, another program unit easily calls the updated program unit. be able to. That is, the calling program unit simply calls the dynamic link library by designating the updated program unit of the call destination, and the updated program unit is called regardless of whether the updated program unit is updated.

The calling program unit does not need to know the memory address of the area in the main memory (real memory) assigned to the calling program unit. In this example, whether the instructions written in the intermediate code are interpreted and executed as intermediate code in the interpreter,
Create a mechanism to determine whether to execute the native code prepared for the instruction, and if the result of the determination is the latter, call the dynamic link library by specifying the native code to be executed by the interpreter. Good. The dynamic link library is
Loads the called program unit into memory and links to the calling program unit for execution.

However, most of the real-time OSs generally used in the microcomputer system field do not support the dynamic link library. Under an OS that does not support the dynamic link library,
Static links are used. In the present case, the interpreter and the native code are statically linked to generate one load module, which is loaded into the memory and executed.

Generally, among program units linked by static linking, the calling program unit is
The address on the memory assigned to the called program unit can be known in advance, and when actually calling the called program unit, the call can be executed by using this memory address.
Therefore, if you statically link the interpreter and native code to generate one load module,
It is easy for the interpreter and native code to call each other.

However, when the interpreter and the native code are statically linked, when the native code is changed to the new native code, it is not enough to replace the native code loaded in the memory with the new native code. , It is necessary to statically relink the original interpreter and the new native code again to generate a new load module and load it into the memory.

As described above, in most ordinary real-time OSs, when a set of native code and intermediate code is executed by the interpreter, the conventional program execution control for statically linking and executing the interpreter and the native code is executed. The method has a problem that it is not easy to replace the native code with new native code.

Therefore, an object of the present invention is to allow an interpreter to sequentially interpret and execute intermediate code on an OS that does not have the function of a dynamic link library, and to improve the speed, replace the native code with a part of the intermediate code. To provide a program execution control method and an execution control program that facilitate replacement of a native code even when it is directly executed on a computer without passing through an interpreter.

[0012]

A program execution control method according to the present invention is a native program obtained by compiling an intermediate code part obtained by compiling a part of a source program and another part of the source program. A program including a plurality of program parts, the intermediate code part being interpreted and executed by an interpreter, and each of the plurality of native program parts being directly executed by a computer without passing through the interpreter. A control method, wherein the plurality of native program parts are stored in a predetermined area dedicated to native code in a main memory, and information for calling each native program part is stored. The interface table is the native code The execution of the intermediate code portion is started in a state of being stored at a predetermined position in the use area, and the nativeized program portion corresponding to the instruction to be executed next in the intermediate code portion is the plurality of natives. When included in a localized program part, the information for calling the corresponding nativeized program part is read by the interpreter from the interface table, and the corresponding nativeization is performed using the read information. The step of calling the executed program part by the interpreter is included.

As a result, when there is a nativeized program part corresponding to the next instruction to be executed in the intermediate code part, the nativeized program part can be used as the instruction by the computer without passing through the interpreter. Directly executed. If some or all of the multiple natively converted program parts are changed later, change the contents of the above interface table to
Adapting and updating the modified native program parts, loading the modified multiple native program parts into the native code dedicated area, and further modifying the interface table dedicated to the native code The interpreter can read the modified interface table by loading it at the predetermined position in the area, and the modified information in the interface table can be used to read the plurality of native programs. Despite the modification of the part, any of the modified native program parts can be called.

Preferably, the execution start step of the program stores another interface for storing information for calling each of the plurality of unique program parts provided in the interpreter from any of the native program parts. The execution of the program is started in a state where the table is stored in a predetermined position in the native code dedicated area, and the program execution control method is characterized in that, while any one of the plurality of nativeized program parts is executing, Information for calling one of a plurality of unique program parts is read from the other interface table by the running nativeized program part, and the read information is used to read the unique program. Portion the running nativeized program Calling from the portion is to further comprise a step.

With this, when any of the nativeized program parts is being executed, a unique program part in the interpreter can be called from the program part, and the nativeized program part is provided in the interpreter. Available program resources.

More preferably, the other interface table is a table further storing information for calling the interpreter from any of the nativeized program parts, and the program execution control method is the plurality of the plurality of interface tables. Information for calling the interpreter during execution of any of the native program parts of the program is read from the other interface table by the executing program part, and the information read for the interpreter is used. And then calling the interpreter from the running nativeized program portion.

As a result, when any of the native program parts is being executed, it is possible to call an interpreter from the program part and request processing, and the native program part is a program called an interpreter. Resources can be used.

[0018]

BEST MODE FOR CARRYING OUT THE INVENTION One embodiment of a program execution control method and a program execution control program according to the present invention will be specifically described below with reference to the drawings.

FIG. 1 is a diagram showing an example of a process of generating an application program including a combination of an intermediate code and a native code. First, the source program 10 is compiled by the intermediate code compiler 20 to generate the intermediate code 30 that can be executed by the interpreter 120. The source program 10 includes a plurality of modules 10
A, 10B, 10C, ...
Intermediate code 30A, 30B, 3 corresponding to each module
0C, ... are included.

In recent years, as a source program, a program written in an object-oriented programming language, which is suitable for handling various objects to be handled collectively by paying attention to a common property, is often used. In a source program written in this language, objects representing various objects are defined as classes. A class is a concept that abstracts objects. The definition of the class includes the definition of various data and the definition of the method that defines various processing contents. Also in this embodiment, it is assumed that the source program 10 is written in an object-oriented programming language.

The system designer or another person concerned determines the portion of the obtained intermediate code 30 to be speeded up by an appropriate method. The part to be speeded up is the part that becomes the bottleneck in the execution performance of the application program, and the speeding up of that part improves the overall performance of the application program. A method for selecting such an intermediate code portion to be speeded up is already known. Here, for example, it is assumed that the intermediate code portion 30A is an intermediate code that is desired to be speeded up.
It is assumed that the intermediate code portion 30A to be accelerated includes a plurality of methods.

The intermediate code portion 30A is compiled by the intermediate code conversion compiler 40 to generate a corresponding high level language program 50. The intermediate code conversion compiler 40 is configured to generate the first and second interface tables 60 and 70 in addition to the high-level language program 50 as a compilation result of the intermediate code portion 30A to be speeded up.

It is assumed here that the high-level programming language that describes the high-level language program 50 is different from the high-level programming language that describes the source program 10.
The high-level programming language that describes the high-level language program 50 may be the same as the high-level programming language that describes the source program 10. For example, the high-level programming language that describes the high-level language program 50 is C or C ++, and the programming language that describes the source program 10 may be another programming language or the same programming language.

The first and second interface tables 60 and 70 may be referred to as a native code interface table and an interpreter application program interface table, respectively. First, second
The interface tables 60 and 70 will be described later. As will be described later, some information (memory address) of the plurality of information to be stored in the first and second interface tables 60 and 70 is not determined when these tables are generated, and will be described later. , Is determined at the time of linking by the native linker 100.

The obtained high-level language program 50 is compiled by the native compiler 80 to generate the object module 90, and the first and second interface tables 60 and 70 are set to the same native compiler 8.
Compile with 0 to generate two corresponding object modules 60A and 70A.

In the following, in order to simplify the object module 60A obtained from the first interface table 60, the first interface table or the first interface table
In some cases, it is referred to as an object modularized interface table of, or a native code interface table or an object modularized native code interface table. Similarly, the object module 70A obtained from the second interface table 70 is also called the second interface table or the second object modularized interface table for simplification, or the interpreter application program interface table or the object module. It may be called a computerized interpreter application program interface table.

The obtained object module 90 and the object module-formed first and second interface tables 60A and 70A are stored in the native linker 10.
Link with 0 to generate native code 110. At this time, the plurality of methods included in the object module 90 are statically linked to the object moduleized interface tables 60A and 70A.

The obtained native code 110 includes a plurality of native code portions 110 corresponding to a plurality of methods included in the intermediate code portion 30A to be speeded up.
A, 110B, ... And first and second natively coded interface tables 600, 700 corresponding to the first and second interface tables 60, 70 are included. In the following, the intermediate code part 30A that you want to speed up
The native code portions 110A, 110B, ... Corresponding to the plurality of methods included in the above may be simply referred to as native methods. Also, the natively coded first and second interface tables 600 and 700 may be referred to as first and second interface tables or first and second native interface tables for simplification. Also, the natively coded interface tables 600 and 700 may be referred to as a native code interface table and an interpreter application program interface table, respectively.

Since the interpreter 120 and the native code 110 are executed while being switched, the native compiler 80 and the native linker 100 are executed when the interpreter 120 is built (that is, the interpreter 1).
Compile 20 source programs and link the resulting object modules to produce a load module for use as an interpreter).

Thus, the intermediate code 30 corresponding to the source program 10 and the native code 110 are generated. The native code 110 includes a plurality of program parts (here, a plurality of native methods) 110A, 1A corresponding to the part of the intermediate code 30 to be accelerated.
10B and two nativeized interface tables 600, 700 corresponding to the two interface tables 60, 70 are included.

The native program parts 110A and 110B and the native interface tables 600 and 700 are collectively referred to as native code. However, in the following description, the nativeized interface table 60
Either or both of the program parts 110A and 110B that are nativeized without including 0 and 700 may be referred to as native code. In particular, when referring to the replacement of a native program, native code refers to the part of the program that has been nativeized.

Nativeized interface tables 600 and 700, especially interface table 600
Is the nativeized program part, eg 100
This is because even when A or 100B is replaced, it is a table that holds data for the interpreter to call a new native program part, and is not the program part to be replaced.

Intermediate code 3, as will be described in detail later.
0 parts 30B and 30 other than the speed-up target part 30A
The C is sequentially interpreted and executed by the interpreter 120. Regarding the execution of the acceleration target portion 30A, the program portion in the native code 110, for example, the native methods 110A and 110B is executed by the interpreter 120.
And is executed directly by the computer without being interpreted and executed by the interpreter 120.

The first interface table 600 is
The interpreter 120 includes a plurality of program parts in the native code 110, for example, a plurality of methods 110A, 1
It is provided to call any method of 10B and is referenced by the interpreter 120. The second interface table 700 includes the native code 110.
Program part inside, eg native method 110
With A being executed, the native method 1
10A is provided to make program resources available for interpreter 120. In order to enable the use of such program resources,
Switching module 1 separate from interpreter 120
30 is prepared in advance, and the second interface table 700 is referred to by the switching module 130.

An example of the program resource for the interpreter is a program specific to the interpreter provided in the interpreter 120, for example, a library function defined in the interpreter 120. Examples of library functions are searching strings or converting characters to numbers. Hereinafter, such a program unique to the interpreter 120 will be referred to as a unique method. When the native method 110A wants to use such a unique method, the switching module 130 is called, and the switching module 130 calls the unique method designated by the native method 110A using the second interface table 700.

The second interface table 700 is
The executing native method 110A is also used to make the interpreter 120 itself callable. For example, when it is desired to request the interpreter to execute a method described in the intermediate code (hereinafter, may be referred to as an intermediate code method for simplification), the executing native method 110A calls the interpreter 120, You can request calls to intermediate code methods. This method is decoded and executed by the interpreter 120.

FIG. 2 is a diagram showing a memory area in the main memory (real memory) that is assigned to various programs when the application program is executed in this embodiment. The memory includes an OS area 210, an interpreter area 220, and a native code reserve area 23.
0, an intermediate code expansion area 240, and an intermediate code stack area 250 are provided. When interpreting and executing all the intermediate codes by the interpreter without using the native code, areas 210, 220, 24 other than the area 230 are used.
Only 0,250 are used.

In this embodiment, a native code reserve area 230 is provided as a native code dedicated area in order to enable replacement of the native code. To implement native code replacement, the native code reserve area 230 is first reserved in advance by the real-time operating system so as not to be crushed for other uses. For this purpose, for example, the native code reserve area 23
The value 0 is secured, for example, immediately below the interpreter area 220 before the interpreter starts its operation. Further, it is convenient to use another area secured by the OS thereafter as an address area below the native code reserve area 230.

The area in the interpreter area 220 is also allocated to the switching module 130 newly provided to realize the replacement of the native code. An area in the interpreter area 220 is also allocated to a method specific to the interpreter, for example, 140. In practice, interpreter 120 typically uses multiple native methods, but only one native method 140 is shown in the figure for simplicity.

The native code reserve area 230 is assigned to the native code 110. That is, this area is also allocated to the program parts 110A and 110B which are included in the native code 110 and are made native, and the first and second interface tables 600 and 700 which are made native.

FIG. 3 shows the first interface table 6
It is a figure which shows the example of 0. The first interface table 60 has three fields 6 for each of a plurality of program units that have been made native, for example, a plurality of methods.
Holds 1 to 63. The field 61 stores the name of the method that has been natively coded, that is, the name of the function. In the C programming language, a character string indicating the name of the function is chained in this field. In the field 62, a character string indicating the argument information of the method is chained. The argument information is information that specifies constraint conditions regarding the arguments of the method such as the total number of arguments used to call the method and the type of each argument. The field 63 stores the memory address that actually stores the native code of the method.
This memory address indicates the entry address when calling the method.

When the first interface table 60 is generated by the intermediate code conversion compiler 40, the method name and the argument information are stored in the fields 61 and 62, but the memory address has not yet been determined and the field 63 has not been determined. Is not set to. When the object module 90 and the objectized interface tables 60A and 60B are linked by the native linker 100, the memory address of each method is determined. Therefore, the native linker 100
When linking, the memory address of each native method is set in the field 63 for that method in the interface table 60 to complete the nativeized interface table 600.

Instead of causing the native linker 100 to store the memory address of each method in the nativeized interface table 600, another method may be used. For example, the system designer looks at the address data output by the native linker 100 in association with the link, stores it in the interface table 60 before being nativeized by command input, and then compiles it again by the native compiler 80 The link by the linker 100 may be executed.

FIG. 4 shows the second interface table 7
It is a figure which shows the example of 0. The second interface table 70 is used when a native method held by the interpreter 120 side, for example, a so-called library function is called during execution of the native method 110A or 110B, or when a method prepared as intermediate code is called through the interpreter. used. Since the second interface table 70 is statically linked with the program parts (native methods 110A and 110B) in the native code 110, it can be read from each native method.

The second interface table 70 has three fields 7 holding information about the interpreter.
Corresponding to 1, 72, 73 and each unique method, three fields 7 for holding information about the unique method
4,75,76 are included. The name of the interpreter is registered in the interpreter field 71. More specifically, a character string representing the name of the interpreter is chained in this field. In the field 72, a character string indicating information about an argument used when calling the interpreter 120 is chained. The argument information is information that specifies constraint conditions regarding the arguments of the interpreter 120, such as the total number of arguments used to call the interpreter 120 and the type of each argument. The field 73 stores the memory address of the interpreter, that is, the start address of the function having the interpreter function.

The field 74 stores the name of the unique method, that is, the name of the library function. Specifically, a character string indicating the name of the function is chained in this field. As shown in the figure, when the unique method is a sysprint method that outputs a character string or a numerical value to the standard output, the method name “sysprint” is stored in the field 74. In the field 75, a character string indicating the argument information of the method is chained. The argument information is the total number of arguments used to call the method,
This is information that specifies the constraint conditions for the arguments of the method such as the type of each argument. In the case of the sysprint method, as shown in the figure, the character strings "Addr, Add
r, ..., Is stored. The memory address of the unique method is stored in the field 76. This memory address indicates the entry address when the method is called.

When the second interface table 70 is generated by the intermediate code conversion compiler 40, information other than the memory address regarding the interpreter and the unique method is set in the table, but the memory address is not set. This is the same as when the interface table 60 is generated. When the nativeized interface table 700 is generated, the memory address of the unique method and the memory address of the interpreter 120 are set in the interface table 700 to complete the interface table 700. Is the same as. The second interface table 70
It is assumed that the memory address of the interpreter 120 and the memory address of the native method that should be set to 0 have already been determined when generating the load module for the interpreter 120.

FIG. 5 is a schematic flowchart of the execution procedure of the intermediate code in this embodiment. First, load the real-time OS into the OS area 210 (FIG. 2) normally (or if the memory is ROM, read the O
Real-time OS (incorporated in S area 210)
The initialization process of is executed (step S101). In the initialization process, the native code 110 generated in advance by the method described above is copied (loaded) into the native code reserve area 230 of the memory (step S102). At this time, the nativeized interface tables 600 and 700 included in the native code 110 are also copied together with the program parts 110A and 110B in the native code 110.

It is assumed here that, as is usually the case, the intermediate code 30 is provided via a network (not shown) or from outside the computer using a portable recording medium. Therefore, it is assumed that the entity is first placed not on the execution memory of the computer system but on what is called a file system. Similarly, it is assumed that the native code is first placed on the file system using a network or a portable recording medium, and is treated at the beginning of computer operation as if it were there from the beginning before the computer system started operating. The native code 110 is copied (loaded) into the native code reserve area 230.

When the native code 110 is changed, it is necessary for the user to be able to indicate the native code to be copied so that the changed native code is copied. The native code to be copied can be indicated, for example, by a command entered by the user or by a user-specified option of the appropriate instruction.

Next, the interpreter 1 included in the OS
20 starter programs (not shown) are started, and the following processes S103 and S1 are executed by this starter program.
04 is executed. First, the interpreter 120 and the switching module 130 are loaded into the interpreter area 220 (step S103). Interpreter 120
Specifying the intermediate code 30 to be executed causes the interpreter 120 to start executing the intermediate code 30 (step S104).

The interpreter 120 dynamically expands the designated intermediate code in the intermediate code expansion area 240 of the memory, and executes the intermediate code 30 while using the intermediate code stack area 250, as is usually the case. . The intermediate code to be executed is loaded in the intermediate code expansion area 240 and sequentially executed. This intermediate code expansion area 2
A heap area is also included in 40. The loading of intermediate code is done dynamically and the region is released when it finishes executing.
The intermediate code stack area 250 is provided with a stack used when the intermediate code is executed by the interpreter.

In the present embodiment, the native program portion corresponding to the instruction to be executed next in the intermediate code 30 (intermediate code instruction) is the native code 11
If it is included in 0, the instruction is not interpreted and executed by the interpreter, but as the instruction,
The corresponding native code is executed. This speeds up the execution of that instruction. Further, from the running nativeized program portion 110A or 110B to the native program portion (eg, library function) 140 in interpreter 120 or interpreter 120.
Can be called. As a result, the program part 110A or 1
10B can use the program resource in the interpreter or the function of the interpreter 120, similarly to the instruction of the intermediate code.

FIG. 6 is a schematic flowchart showing the operation of executing the intermediate code by the interpreter 120. First, the interpreter 120 refers to the first interface table 600 regarding the intermediate code instruction to be executed, and determines whether or not the method corresponding to the intermediate code instruction is included in the native code 110 as the native method ( Step S111). Here, the method corresponding to the intermediate code instruction is a method used by the intermediate code instruction. For example, if the intermediate code instruction to be executed is an instruction to call any method, that method is the method corresponding to the intermediate instruction.

Since the memory address of the first interface table 600 is fixed, the interpreter 12
0 can refer to the first interface table 600 by using this fixed address. The above determination is made by using the field 6 for the method whose method name is any in the first interface table 600.
It can be determined by whether or not the method name registered in 1 matches.

If the method name is not registered in the first interface table 600, the interpreter 120 interprets and executes the intermediate code instruction (step S112), and proceeds to step S117.

If the name of the method is registered in any of the fields 61, the argument is set according to the method argument information 62 registered corresponding to the method name (step S113). That is, the arguments used for the call are set so as to satisfy the constraint conditions concerning the arguments such as the number of arguments and types. Another example of the constraint condition is that up to four arguments whose size can be placed in a register are placed in the register, and arguments of other sizes are placed in the stack. When the argument information indicates this constraint condition, a plurality of arguments used for the call are divided into a register and a stack and set according to the constraint condition.

Next, the memory address for the method is read from the field 63 for the method, and the native method is called using the memory address (step S114). In this way, the native method can be called from the interpreter 120. The called native method is executed directly by the computer. As a result of the execution of the native method, if there is a return value from the native method, the interpreter 120 takes over the return value to the intermediate code side (step S116). Thus, the intermediate code instruction is executed using the corresponding native method, and the process proceeds to step S117.

When the execution of the intermediate code instructions is completed as described above, it is judged whether or not the execution of all the intermediate code instructions is completed (step S117). If not, the above-mentioned processing is followed by the subsequent intermediate code instructions. , And when all the intermediate code instructions have finished executing,
Program execution ends.

In the present embodiment, the above step S114.
It is also possible to call a unique method included in the interpreter 120 or the interpreter 120 from a native method called and executed by the. Specifically, when the native method included in the interpreter 120 or the interpreter 120 is called during the execution of the native method (step S115), the switching module 130 is called.

FIG. 7 is a schematic flowchart of the processing of the switching module 130. First, it is determined whether the call destination is the unique method or the interpreter 120 (step S131). When the callee is the unique method, the argument information of the unique method of the callee is read from the nativeized interface table 700 (step S132), and the argument is set according to the read argument information (step S133). . An example of the process of setting the argument according to the argument information is as described regarding step S113 of FIG. 6 in the case where the interpreter 120 calls the native method.

In FIG. 7, the memory address of the call destination is read from the nativeized interface table 700 (step S134), and the unique method is called using the read memory address (step S135). When there is a return value from the specific method as a result of the execution of the specific method, the switching module 130 sets the return value to the program part (native method 110A or 11) in the native code.
0B) (step S136). by this,
The native method of the caller can continue processing by using the processing result of the unique method of the callee. Thus, the processing of the switching module 130 when the callee is the unique method is completed.

On the other hand, if it is determined in step S131 that the call destination is the interpreter 120, the argument information of the interpreter 120 is read from the nativeized interface table 700 (step S137).
An argument is set according to the read argument information (step S138). The memory address of the interpreter 120 is read from the nativeized interface table 700 (step S139), and the interpreter 120 is called using the read memory address (step S140).

If there is a return value from the interpreter 120 as a result of the execution of the interpreter 120, the switching module 130 sets the return value to the program part (native method 11) in the native code.
0A or 110B) (step S141). This allows the calling native method to continue processing using the processing result of the interpreter. Thus, the processing of the switching module 130 when the callee is the interpreter 120 is completed.

As described above, when a native method, for example, 110A is called and executed by the interpreter 120, the native method 110A interprets the interpreter 120 itself or the interpreter 120.
You can use the specific method for.

When the designer of the microcomputer system changes the contents of the intermediate code portion 30A that the user wants to speed up, the method contained therein is changed. The method change can include, for example, changing the content of the method, adding another method, replacing it with another method, and the like. as a result,
Generated native program part 110
Any of the method name, argument information, and memory address of either A or 110B may change. Therefore, the modified native program part 1
It is necessary to change the first interface table 600 to match 10A and 110B.

That is, regarding the first interface table 600, when a change other than the memory address is to be made, when the change is generated by the intermediate code conversion compiler 40, the change is reflected in the interface table 60 generated at that time. ing. Regarding the first interface table 600, when the memory address should be changed, the change is performed by the object module 9
When 0 and the object moduleized interface tables 60A and 70B are linked by the native linker 100 to generate the native code 110, they are reflected in the generated nativeized interface table 600.

When the changed native code 110 thus generated is copied to the native code reserve area 230 in step S102 of FIG. 5, the nativeized program part and the interface table 600 are also updated. However, since the storage location of the changed interface table 600 is fixed, the interpreter 120 can read the changed interface table 600 as before. The interpreter 120 uses the interface table 6
The modified information in 00 can be used to call any of the modified native program parts. It is not necessary to link the changed native code with the interpreter when changing the part of the program that has been made into a native form, and it is not necessary to perform any processing regarding the interpreter. Therefore, replacement of the nativeized object part becomes easy.

The second interface table 70
0 is unaffected by changes to the nativeized object part. This table 700 is for interpreter 1
20 or need to change when the native method in the interpreter changes. The changing method can be performed in the same manner as the changing of the first interface table 600.

[0070]

As described above, according to the present invention,
The intermediate code is serially interpreted and executed by an interpreter on an OS that does not have the function of the dynamic link library, and the native code is directly executed on the computer instead of a part of the intermediate code for speeding up without passing through the interpreter. Replaces native code easily in the system.

[Brief description of drawings]

FIG. 1 is a diagram showing an example of a process of generating an application program including a combination of intermediate code and native code.

FIG. 2 is a diagram showing memory areas assigned to various programs when an application program is executed.

FIG. 3 is a diagram showing an example of a first interface table.

FIG. 4 is a diagram showing an example of a second interface table.

FIG. 5 is a schematic flowchart of an execution procedure of a program including intermediate code according to the embodiment of the present invention.

FIG. 6 is a schematic flowchart of an intermediate code execution operation by an interpreter.

FIG. 7 is a schematic flowchart of processing of a switching module.

Claims (9)

[Claims] 1. An intermediate code of a program including an intermediate code part obtained by compiling a part of a source program and a plurality of nativeized program parts obtained by compiling other parts of the source program. A method of controlling execution of a program, wherein a part is interpreted and executed by an interpreter, and each of the plurality of native program parts is directly executed by a computer without going through the interpreter, the plurality of native programs A part is stored in a predetermined area dedicated to native code in the main memory, and an interface table storing information for calling each of a plurality of nativeized program parts is stored in a predetermined position in the area dedicated to native code. In the memorized state, When a plurality of native program parts corresponding to instructions to be executed next in the intermediate code part are included in the plurality of native program parts. Reading the information for calling the localized program part from the interface table by the interpreter, and using the read information to call the corresponding nativeized program part by the interpreter. And program execution control method. 2. The information for calling each nativeized program part in the interface table includes argument information that specifies constraints on arguments used for calling the program part and a memory address of the program part, The reading step reads the argument information included in the information for calling the nativeized program part to be called and the memory address of the nativeized program part, and the calling step is based on the read argument information. Setting the argument to be passed to the corresponding nativeized program part based on the above, and calling the corresponding nativeized program part using the read memory address. The program described in 1. Execution control method. 3. The step of starting execution of the program,
Another interface table storing information for calling each of a plurality of unique program parts provided in the interpreter from any of the native program parts is stored at a predetermined position in the native code dedicated area. Information for calling any one of the plurality of unique program parts while the one of the plurality of native program parts is being executed. Read from the other interface table by the programmed program portion and using the read information to call any of the unique program portions from the running nativeized program portion. The program implementation according to claim 1 or 2, characterized in that Control method. 4. The information for calling each peculiar program part includes argument information designating a constraint concerning an argument used for calling the peculiar program part and a memory address of the peculiar program part, and the other information. The step of reading the information from the interface table of, reading the argument information included in the information for calling the unique program portion to be called and the memory address of the unique program portion, the step of calling the unique program portion, An argument to be passed to the unique program portion to be called is set based on the argument information read out to the unique program portion, and the calling is performed using the memory address read out to the unique program portion to be called. Power specific blog Program execution control method according to claim 3, characterized in that it comprises the step of invoking the arm portion. 5. The other interface table further stores information for invoking the interpreter from any of the nativeized program parts, during execution of any of the plurality of nativeized program parts. , The information for calling the interpreter is read from the other interface table by the executing program part, and the nativeized program executing the interpreter using the information read about the interpreter. 5. The program execution control method according to claim 3, further comprising a step of calling from a part. 6. The information for calling the interpreter includes argument information that specifies constraints on arguments used to call the interpreter and a memory address of the interpreter, and calls the interpreter from the other interface table. The step of reading information reads the argument information included in the information for calling the interpreter and the memory address of the interpreter, and the step of calling the interpreter is based on the argument information read with respect to the interpreter. The program execution control method according to claim 5, further comprising the step of setting an argument to be passed to the interpreter, and calling the interpreter using the memory address read with respect to the interpreter. 7. A native code obtained by compiling an intermediate code part obtained by compiling a part of a source program and another part of the source program, which is directly executed by a computer without passing through the interpreter. A program execution control program for controlling execution of a program including a plurality of program parts, the interpreter sequentially decoding and executing the intermediate code part, and for calling the plurality of nativeized program parts An interface table storing information, wherein the plurality of native program parts are stored in a predetermined native code dedicated area in the main memory, and the interface table is stored in the predetermined native code dedicated area. Is stored in a predetermined position of When a plurality of native program parts corresponding to an instruction to be executed next in the intermediate code part are included in the plurality of native program parts, the interpreter corresponds to the corresponding native program part. A program execution control program, which reads information for calling from the interface table and calls the corresponding nativeized program part using the read information. 8. Information for calling each of a plurality of unique program parts stored in a predetermined position in the native code dedicated area and provided in the interpreter from any of the nativeized program parts. The stored other interface table and information for calling any of the plurality of unique program parts while any of the plurality of native program parts is executing, the running nativeized program A program for reading from the other interface table by the part and using the read information to call any one of the unique program parts from the running nativeized program part. The program execution control program according to claim 7. 9. The other interface table is a table further storing information for calling the interpreter from any of the nativeized program parts, and any one of the plurality of nativeized program parts. During execution, information for calling the interpreter is read from the other interface table by the program part in execution, and the information read for the interpreter is used to execute the interpreter. 9. The program execution control program according to claim 8, further comprising: a program called from a nativeized program part.