JP2001092672A - Method and device for rewriting instruction code and information recording medium - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a method for rewriting an instruction code whose executing efficiency is improved. SOLUTION: A compiler for compiling a source program to an execution program generates a name reference and solution calling instruction for calling a name solution procedure for solving a name which can be solved only at the time of program execution and an instruction without any side effect having name identification information for identifying the name which can be solved only at the time of program execution and the number of a target register for storing a solved name. Then, the instruction without any side effect generated by the compiler is distributed to a delayed slot. Then, at the time of executing an execution program, the name solution procedure is called according to the name reference and solution calling instruction, and the name reference and solution calling instruction and the instruction without any side effect are rewritten into an instruction for storing a value obtained by solving the name in the target register based on the instruction without any side effect.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a method of rewriting an instruction code of a program which performs processing while rewriting an instruction of the program to be executed when the program is executed.

[0002] The present invention also relates to an instruction code rewriting device and an information recording medium for rewriting an instruction code by such a method.

[0003]

2. Description of the Related Art The main purpose of rewriting an instruction code of a program to be executed at the time of executing the program is to solve at execution time a value which can be solved only at the time of executing the program and to embed the value in the program code.

[0004] The values that can be known only at the time of program execution include the entry address of the runtime library and the
This is the global variable name of the system, but also the offset of a specific field of an object in an object-oriented program, the address of a static variable of a class, and the like.

[0005] Some of this information can be resolved at the time of loading the program. However, in a situation where the variable must be resolved at the first access to the variable, such as the Java language, the variable is stored during execution of the program. Just when you first access it, you need to resolve the name.

At this time, if the name information and the resolved value are held in the data section, it is not necessary to rewrite the instruction code of the program at the time of execution. In this case, however, a process for resolving the name is called. Code, and this call must be performed each time the part is executed, even after the name is resolved.

In order to solve the above problems, a method has been adopted in which the result of name resolution during program execution is reflected in the instruction code of the program.

FIG. 27 is a diagram for explaining a conventional name resolution process.

In FIG. 1, "arg" is a register or stack address which becomes a first argument in a procedure call, and "val" is a register for returning a return value.

“Call” is a procedure call instruction (jump & link), and “NameID” is an ID for identifying a name.

"ResolveName" is an entry address for name resolution processing, "resolvedValue"
"e" is a name-resolved value.

"DstReg" is a register in which the resolved value is to be stored (if it is the same as val, a copy instruction to this register is unnecessary).

Usually, two instructions are required to write 32-bit data to a register, and therefore, the same number of instructions are required for an instruction sequence after name resolution. Even if a value resolved by one instruction can be written to a register, a nop instruction must be arranged to have the same number of instructions as before rewriting.

Since this method complies with the procedure calling rule, hereinafter, it is referred to as "name resolution processing calling method according to the procedure calling rule".

Here, the "procedure calling rule" (also called linkage convention, ABI, etc.) will be briefly described.

The procedure calling rule is a rule defined for each instruction set architecture of each microprocessor. As long as the rules are followed, it is possible to write a program in any language and call the program procedure mutually. It becomes.

In the procedure call rule, in a procedure call, up to what number of argument data is held in which register, how other argument data is held on the stack, and the return address is determined by which register ( Or, the return value defines which register (or relative position on the stack) to hold in a specific relative position on the stack. Here, the return address is an address for returning to the calling source after completing the called procedure.

Then, it is guaranteed that the contents of some registers are the same before and after the procedure call. For example, in the mips architecture,
Of the 32 registers 0 to $ 31, $ 16 to $ 23
, $ 29 (= $ sp stack pointer), $ 3
A value of 0 is guaranteed to be the same before and after the procedure call.

In order to comply with this convention, when using the above register in a procedure, the contents of the register are saved on the stack at the entry of the procedure, and when returning from the procedure,
A process of restoring the saved value to the original register is performed. These registers are called call-saved registers.

Conversely, if it is desired to hold a certain value in a register across a procedure call, a register whose value is guaranteed must be used before and after the procedure call. This restriction also becomes an obstacle for realizing efficient processing when the name resolution processing is performed according to the procedure calling rules.

For example, in a series of processing of ＄ x ← base address ＄ v ← name resolution (name resolution processing call) ＄ t ← ＄ x + ＄ v, ＄ x is a call-save
Must be a d register. Then, at the entrance and exit of the procedure including the above series of processes, this call
Processing for saving and restoring the ee-saved register must be performed.

Next, "name resolution processing according to procedure calling rules" will be described.

According to the procedure calling rules, the result of name resolution is returned in a specific register, and the value must be copied to another register.

Assuming that a specific register is RV and a register temporarily used is T, when a series of processing as shown in FIG. 29 is performed, the last X is referred to as shown in FIG. , The resolved value must be copied to the temporary register T.

[0025]

According to the method shown in FIG. 27, a register for holding a value whose name has been resolved must be a register (val) for returning a return value in a procedure call.

When the value to be resolved is the field offset information of the object, the memory is accessed by the offset value obtained by the resolution. However, the base address information of the object can be passed to the name resolution processing. Therefore, the instruction code for memory access must be placed after the name resolution processing call as shown in FIG.

Further, the register for holding the value whose name has been resolved must be a register for returning a return value, the name ID must be stored in the argument register, and reference is made across the name resolution processing. For example, the data to be processed must be a call-save register, and the name resolution processing calling method according to the conventional procedure calling rules has a severe limitation, and it has been difficult to make an efficient instruction code.

The present invention has been made in view of the above circumstances, and provides an instruction code rewriting method capable of improving the execution efficiency of a target code generated as a result of name resolution and instruction code rewriting during program execution. The purpose is to do.

Another object of the present invention is to provide an instruction code rewriting device for rewriting an instruction code by such an instruction code rewriting method and a computer-readable information recording medium.

[0030]

Therefore, in order to achieve the above object, a first aspect of the present invention is to provide a compiler which compiles a source program into an executable program, by using a name which can be resolved only when the program is executed. A name reference resolution call instruction for calling a name resolution procedure for resolution; name identification information for identifying a name that can be resolved only when the program is executed; and a target register number for storing the resolved name. An instruction having no side effect is generated, and in the compiler, the generated instruction having no side effect is arranged in a delayed slot, and when the execution program is executed,
In the name resolution procedure called by the name reference resolution call instruction, rewriting the name reference resolution call instruction and the instruction having no side effect into an instruction for reading a value obtained by resolving the name into a target register based on the instruction having no side effect. And a method of rewriting an instruction code.

According to the invention, in the name resolution procedure, the name reference resolution call instruction and the instruction having no side effect are stored in the target register based on the instruction having no side effect, which is generated by the compiler and is arranged in the delayed slot. Since the instruction for storing the name-resolved value is rewritten, the execution efficiency of the target code can be improved.

According to a second aspect of the present invention, there is provided a compiler for compiling a source program into an execution program.
A name reference resolution call instruction that calls a name resolution procedure for resolving the name of an object field that can only be resolved at program execution, and a name for identifying a name of the object field that can be resolved only at the time of program execution Generating an instruction having no side effect having identification information, a number of a destination register for storing the resolved name and a base address of the object, and placing the generated instruction having no side effect in a delayed slot in the compiler; In executing the execution program, in the name resolution procedure called in the name reference resolution call instruction, the name reference resolution call instruction and the instruction without side effect are named in the base address of the object based on the instruction without side effect. Instruction code rewriting method characterized by rewriting the instruction to read the data of the address obtained by adding the value persists in the destination register is.

According to the invention, in the name resolution procedure, the name reference resolution call instruction and the instruction having no side effect are converted into the base of the object based on the instruction having no side effect arranged in the delayed slot generated by the compiler. Since the data at the address obtained by adding the value obtained by resolving the name to the address is rewritten to the instruction for loading the target register, the execution efficiency of the target code can be improved.

Further, a third invention provides a compiler for compiling a source program into an execution program, a name reference resolution call instruction for calling a name resolution procedure for resolving a name that can be resolved only at the time of program execution, Base address of the
The compiler generates name identification information for identifying a name that can be resolved only at the time of program execution, and an instruction without a side effect having a register number that holds a value to be stored in an object field.
The generated instruction having no side effect is arranged in a delayed slot, and in executing the execution program, in the name resolution procedure called by the name reference resolution call instruction, the name reference resolution call instruction is executed based on the instruction having no side effect. And rewriting the instruction having no side effect into an instruction for storing a value held in the register of the register number to an address obtained by adding a value obtained by resolving a name to a base address of the object, and rewriting the instruction code. ,.

According to such an invention, in the name resolution procedure, the name reference resolution call instruction and the instruction having no side effect are registered in the register number based on the instruction having no side effect arranged in the delayed slot generated by the compiler. Since the value stored in the register is rewritten into the instruction for storing the value obtained by adding the value obtained by resolving the name to the base address of the object, the execution efficiency of the target code can be improved.

Further, in a fourth invention based on the second invention or the third invention, the compiler analyzes a precedence relationship of an object field access, and the name resolution procedure includes a result of the precedence analysis by the compiler. A plurality of names are resolved based on

According to such an invention, even when there are a plurality of object field accesses, a plurality of names can be resolved based on the pre-analysis result of the compiler. The execution efficiency can be further improved as compared with.

The fifth invention of the present invention is a program code rewriting device for executing the program code rewriting method and a computer readable information recording medium recording a program for executing the program code rewriting method.

In the above-described invention, the name may be a static variable of an object-oriented program, a variable related to object field access, or a variable related to a static method call of the object-oriented program.

[0040]

Next, an instruction code rewriting method according to an embodiment of the present invention will be described.

First, a rough processing flow of the instruction code rewriting method according to the embodiment of the present invention will be described.

As shown in FIG. 1, the source program 1
Is converted into an execution program 3 before name resolution by a compiling process by the compiler 2. Then, the execution program 3 before the name resolution is executed, while executing the name resolution processing in the procedure of the name resolution processing called by the procedure call instruction, and the instruction code is rewritten (instruction code rewriting processing 4).
The execution program 5 after the name resolution (after rewriting the instruction code) is generated.

The feature of the instruction code rewriting method of the present invention lies in the instruction code rewriting method in the compile processing and the name resolution processing in the compiler described above.

The compile process (code generation process) in the compiler will be described below.

In the instruction code rewriting method according to the present embodiment, in the code generation processing of the compiler, during the execution of the program, the code for accessing the variable whose name is to be resolved is generated in the following procedure.

1. When the name to be accessed is a static variable, an instruction having no side effect is generated by using the instruction for calling the name resolution processing and the register number in which the name ID and the value of the resolved name are to be stored.

2. When the name to be accessed is an object variable A. Reading (loading) of object variables Instructions that call name resolution processing, instructions that have no side effects, using the register number that stores the name ID, the register number that stores the base address of the object, and the value that loads the value of the variable Generate

B. Write (Store) Object Variable Generates an instruction without side effects using an instruction that calls the name resolution process, a register number that stores the name ID, the base number of the object, and a register number that stores the value to be stored. .

In an object-oriented language such as Java, not only variable names but also procedure names (methods) are resolved during program execution. In the case of calling a static method, as in the case of the static variable, the method name may be resolved to obtain a value (entry address of the procedure), and the method may be called using the register storing the value.

When calling a virtual method (object method), the virtual method to be called is registered with the register number and name ID storing the base address of the object, as in the case of the object variable.
Generates an instruction using a register number to store the method's entry address. At this time, the generated code includes an instruction to load the method table from the base address of the object and a name I from the method table.
This is an instruction for loading an entry address of a method using an index obtained by solving D.

In this embodiment, an instruction having no side effect is arranged in a delayed slot, so that a NameI
In addition to D, the target register number and the register number containing the base address are entered in the name resolution process resolveNa
Let me know.

Here, "instructions having side effects" include load and store instructions for accessing memory, division instructions for causing a trap at 0%, instructions having memory contents as source operands, and memory addresses for destination operands. More specifically, there are an instruction to write a result to a memory, an instruction to detect an overflow or an underflow by addition, subtraction, multiplication and division to cause a trap, a system call instruction, and an instruction to change the state of a system-shared resource. Those that are not are called instructions without side effects.

The procedure call instruction call holds the return address in a specific register.
Obtain the instruction code arranged in the delayed slot and obtain N
ameID, a target register number, and a base address are obtained.

The instruction of the delayed slot is resol
It is executed once when calling vName, but this prevents information loss or exceptions.

FIG. 9 is a diagram showing an instruction set before name resolution and an instruction set after name resolution when the name is a static address and when the name is an object field. FIG. 22 is a diagram showing an instruction set before name resolution and an instruction set after name resolution when loading and storing the value of a static variable. FIG.
3 is a diagram showing an instruction set before name resolution and an instruction set after name resolution by a mips instruction when loading and storing the value of a static variable.

In the figure, “op” is represented by “|” (=
“OR”), '＾' (= “XOR”), '&' (= “A
ND "), '+' or '-'.

"Call" is a procedure call instruction (jump & link), "resolveNam
"e" is the entry address of the name resolution process, "dstR
“eg” is a register to store the resolved value, “re”
"solvedValue" is a value whose name has been resolved.

A. When the name is a static variable In the case where the name is a static address Before the name resolution, an instruction code (call resolve) for calling the entry address of the name resolution processing is called.
Instruction code (dstReg ← zero op Name ID) for storing the values of “Name” and “zero op Name ID” in the destination register (dstReg)
However, after name resolution, the destination register (dstRe
g) Resolved value (resolvedValue)
(DstReg ← resol)
vedValue).

Here, before name resolution, zero
The value of the op Name ID is stored in the destination register (dstRe
The reason for storing in g) is that the target register is overwritten with the resolved value, so that writing the Name ID has no effect.

In the name resolution processing, this dstReg ←
The instruction code is rewritten by obtaining the NameID and the target register number from the instruction code of zero op NameID.

FIG. 2 is a flowchart showing name resolution processing (instruction code rewriting processing) when the name is a static address.

As shown in the figure, first, all registers used in this processing are saved (S1). Next, the instruction code (dstReg ← ze
load Name (ID) is loaded (S2).

Next, the target register number and the NameID are obtained from the instruction code loaded in S2 (S2).
3), NameID resolved value (resolvedO
ffset) is obtained (S4).

Next, a code for transferring the value (resolvedOffset) obtained by resolving the NameID obtained in S4 to the destination register (dstReg) is generated, and the instruction code is rewritten (S5).

Then, the register saved in S1 is restored (S6), and the process jumps to the head of the rewritten instruction (S7). Thus, the instruction code rewriting process in the case where the name is a static address is completed.

FIG. 3 shows a format of an instruction in the case of mips, and FIG. 4 shows a name solving process.

2. When Loading the Value of a Static Variable The name resolution processing in this case is basically similar to the case where the name shown in FIG. 2 is a static address. A specific difference is that the process of S5 in FIG. 2 is a process of "generating a code for reading a value from the address of a resolved value, storing the value in a target register, and rewriting an instruction code".

When the processing in this case is represented by a mips instruction set, the sixth and seventh lines of the instruction set shown in FIG. 4 are rewritten to the instruction set shown in FIG.

3. When the value of a static variable is stored The name resolution processing in this case is basically similar to the case where the name shown in FIG. 2 is a static address. A specific difference is that the process of S5 in FIG. 2 is a process of “generating a code for writing the value of the source register to the address of the resolved value and rewriting the instruction code”.

When the processing in this case is represented by a mips instruction set, the third line of the instruction set shown in FIG. 4 is rewritten to the instruction set shown in FIG. 25, and the sixth line of the instruction set shown in FIG. The seventh and seventh lines are rewritten to the instruction set shown in FIG.

B. When the name is a container field When loading a value from an object field Before the name resolution processing, a name resolution processing call instruction and ds
tReg ← baseReg op NameID is an instruction code. After name resolution processing, dstRe
g ← resolvedOffset (baseRe
g).

This is an instruction for loading data from the address obtained by adding the resolved offset from the base address of the object and storing the data in dstReg. Here, baseReg is a register holding the base address of the object, and dstR
eg is a register that stores the value of the field of the object. As with the static address, ds
Since tReg is overwritten, there is no problem even if tReg is destroyed before the name resolution processing.

FIG. 5 is a flowchart showing name resolution processing (instruction code rewriting processing) when a name is an object field and a value is loaded from the object field.

As shown in the figure, first, all registers used in this processing are saved (S11). Next, the instruction code (dstReg ← b
load asReg op NameID) (S
12).

Next, the target register number, base register number and N
ameID is obtained (S13), and a value (resolvedOffset) obtained by resolving the NameID is obtained (S14).

Next, a code for loading data to the target register from an address (base register + resolvedOffset) obtained by adding the value (resolvedOffset) obtained by resolving the NameID obtained in S14 and the value of the base register (baseReg) is generated.
The instruction code is rewritten (S15).

Then, the register saved in S11 is restored (S16), and the program jumps to the head of the rewritten instruction (S17). Thus, the instruction code rewriting process in the case where the name is the object field ends. FIG. 6 shows the name resolution process in the case of mips.
Shown in

2. When Storing Values in Object Fields Depending on the architecture of the instruction set, how many bits can be used for immediate operands (immediate) depends on the number of bits that can be used. In the case of mips, N = 16, n
= 5.

In FIG. 9, srcRegNumber
Is a register number holding a value to be stored in the object field.

Before name resolution processing, a name resolution processing call instruction and zero ← baseReg op (Na
meID | (srcRegNumber <<
(N−n)), and after the name resolution process, srcReg → resolveoffset (b
caseReg).

This is an instruction for performing a process of storing the data held in the source register from the base address of the object to an address obtained by adding the resolved offset. Here, baseReg is a register holding the base address of the object, and src
Reg is a register that holds a value to be stored in a field of the object.

FIG. 7 is a flowchart showing name resolution processing (instruction code rewriting processing) when a name is an object field and a value is stored from the object field.

As shown in the figure, first, all registers used in this processing are saved (S21). Next, from the return address, the instruction code (zero ← bas)
eReg op (NameID | (srcReg
Number <<<< (N-n))) is loaded (S
22).

Next, the source register number, base register number and NameID are obtained from the instruction code loaded in S22 (S23), and a value (resolvedOffset) obtained by resolving the NameID is obtained (S2).
4).

Next, a code for storing the data of the source register at an address (base register + resolvedOffset) obtained by adding the value (resolvedOffset) obtained by resolving the NameID obtained in S24 and the value of the base register (baseReg) is generated,
The instruction code is rewritten (S25).

Then, the register saved in S21 is restored (S26), and the program jumps to the head of the rewritten instruction (S27). Thus, the instruction code rewriting process in the case where the name is the object field ends. Note that the name resolution process in the case of mips is shown in FIG.
Shown in

In the case of a CPU without a delayed slot, the instruction following the call resolvename is not executed. Therefore, no matter what is written in the next instruction code, the resolveName can rewrite the next instruction code. Therefore, necessary information (a target register number, a register number including a base address of an object) is stored in FIG. As shown in FIG. 7, it is possible to embed the code appropriately instead of the instruction. FIG. 10 shows information when a value is loaded from an object field. Further, if the destination register in FIG. 10 is a source register, it becomes information when a value is stored in an object field.

Even in the case of a CPU having a delayed slot, if a software interrupt instruction is used instead of a procedure call instruction, control can be transferred to the name resolution processing without executing a delayed slot instruction. However, in this case, it is necessary to perform a name resolution process as a part of the interrupt process.

Further, when the name resolution process is not the target of the branch but is preceded by an instruction, as shown in FIG. 11, if the preceding instruction (prevInst) is arranged in the delayed slot, necessary information can be freely set. Can be coded. In this case, the instruction code rewriting process is almost the same as in FIGS. 5 and 7, but the return address for obtaining information necessary for name resolution is different. FIG. 12 shows a field load name resolution process in the case of mips, and FIG. 13 shows a field store name resolution process.

According to the name resolution processing described above, the resolved value can be directly assigned to the destination register.
Access to the object field is completed by two instructions. However, regarding the access to the object field, the number of instructions before the name resolution is 2 and the number of instructions after the resolution is almost 1 in most cases, so the nop instruction is inserted.

In a normal program flow, access to an object is repeated many times. Also, the offset of each field of an object is all determined when the object is first accessed. If you take advantage of this property,
Upon the first access to an object, it is possible to resolve the name references for subsequent field accesses to that object.

A method for resolving a name reference in a subsequent field access to an object when the object is first accessed will be described below.

First, terms used in the present embodiment will be defined.

Basic block: The largest continuous area that satisfies the condition that processing is executed serially without branching in the middle of each program code segment and that the program is not jumped in the middle. Is not considered).

Dominant relationship between basic blocks: The basic block A controls the basic block B when the condition that the basic block B arrives at the entrance only when the basic block A has already been executed is satisfied. .

Precedent access to an object: An access X to an object precedes an access Y to an object if X and Y are in the same basic block and X
Precedes Y, or the basic block to which X belongs dominate the basic block to which Y belongs.

Top access: An access X to an object O is a top access when there is no access prior to X for an object access belonging to all the classes C to which O belongs.

Link information: information for tracing field access sequentially from the top access.

First, the processing of the compiler will be described with reference to FIG.
And the flowchart of FIG.

First, as shown in FIG. 14, for each object field access, a data area for holding a head access is provided (S31). Next, the program is divided into basic blocks (S32), and the dominant relationship (in a partial order) of each basic block is examined.

Next, the program is searched from the smallest address to the largest address from the beginning to the end (S3).
4) A field access code is generated for each object field access found as a result of the search (S35).

Next, generation of a field access code will be described with reference to FIG.

First, this access is referred to as access A (S
41). Next, there is no link information of access X yet,
It is determined whether the top access held by the access X precedes the access A and whether the distance between the access A and the access X is smaller than a numerical value that can be represented by the link information (S
42).

If it is determined in S42 that the distance between the access A and the access X is smaller than a numerical value that can be represented by the link information, the link of the access X is determined.
The information is the distance between access A and access X, and access A
Is generated as an access other than the head access, the head access of the access A is made the same as the head access of the access X, and the process returns from the <field access code generation> (S43).

On the other hand, if it is determined in S42 that the distance between the access A and the access X is not smaller than a numerical value that can be represented by the link information, a code is generated with the access A as the head access, and the head access of the access A is generated. Is the access A (S44).

FIG. 16 is a flowchart for explaining the resolution of the name reference of a plurality of field load access processes by a single name resolution process call.

As shown in the figure, first, all registers used in this processing are saved (S51).
Next, information for name resolution is loaded from the return address (S52).

Next, link information, a target register number, a base register number, and a NameID are obtained from the information for name resolution loaded in S52 (S53), the name is resolved, and the value of the resolved name is obtained (S54). ), The code is generated and the code is rewritten (S55).

Next, the next field address is obtained from the link information (S56), and the information code is loaded from the next field address (S57).

Then, from the loaded information code, link information, target register number, base register number and N
ameID is obtained (S58), resolved, the value of the resolved name is obtained (S59), a code for loading data from the address (base register + resolved value) to the destination register is generated, and the instruction code is rewritten (S60). .

Next, it is determined whether or not there is a next field address (S61). If it is determined that there is, the process returns to S56. On the other hand, if it is determined in S61 that there is no next field address, the process proceeds to S5.
Restore the register value saved in step 1 (S6
2) Jump to the top of the rewritten instruction (S6)
3).

As a result, it is possible to resolve the name references of a plurality of field load access processes by a single name resolution process call. FIG. 17 shows name resolution processing in the case of mips.

Next, the process of resolving the name reference of a plurality of field store access processes by one name resolution process call will be described with reference to FIG.

As shown in the figure, first, all registers used in this processing are saved (S71).
Next, information for name resolution is loaded from the return address (S72).

Next, from the information for name resolution loaded in S72, link information, source register number,
The base register number and NameID are obtained (S53), the name is resolved, the value of the resolved name is obtained (S74), and code is generated to rewrite the code (S75).

Next, the next field address is obtained from the link information (S76), and the information code is loaded from the next field address (S77).

Then, the link information, the source register number, the base register number and the NameID are obtained from the loaded information code (S78), resolved, the value of the resolved name is obtained (S79), and (base register + resolved value) ) A code for storing the data of the source register at the address is generated, and the instruction code is rewritten (S80).

Next, it is determined whether or not there is a next field address (S81). When it is determined that there is a next field address, the process returns to S76. On the other hand, if it is determined in S81 that there is no next field address, the process proceeds to S7.
Restore the register value saved in step 1 (S8
2) Jump to the top of the rewritten instruction (S8)
3).

As a result, the name reference of a plurality of field store access processes can be resolved by a single name resolution process call. FIG. 19 shows name resolution processing in the case of mips.

FIG. 20 is a diagram showing, prior to and after name resolution, the instruction code of the first access among the object accesses for performing the name resolution processing call. Also,
FIG. 21 is a diagram showing, before the name resolution and after the name resolution, of the instruction code which is not the head access among the object accesses for calling the name resolution processing.

In FIGS. 20 and 21, the instruction length is 32 bits and the bit length representing the register number is 5 bits.
The bit length representing the bit and link information is represented as 6 bits. As shown in FIGS. 20 and 21, it can be seen that for an access other than the head access, the instruction code after name resolution is one instruction.

Although the present embodiment has been described with respect to the instruction code rewriting method, an instruction code rewriting device for rewriting such an instruction code and a computer readable program recording such an instruction code rewriting program are provided. It goes without saying that the present invention can be applied to an information recording medium. Further, as the information recording medium, for example, a CD-ROM, a DV
D, FD, MO, and the like can be given, but are not limited thereto.

[0123]

As described above in detail, according to the present invention,
The execution efficiency of a target code generated as a result of name resolution and instruction code rewriting during program execution is improved. In particular,
Efficient code can be generated for field access of an object in an object-oriented program.

Further, there is no need to hold extra information (such as patch information) for name resolution, and application to an embedded system with a small memory size is facilitated.

[Brief description of the drawings]

FIG. 1 is a view showing a flow of processing of an instruction code rewriting method according to an embodiment.

FIG. 2 is a flowchart showing name resolution processing (instruction code rewriting processing) when the name is a static address.

FIG. 3 is a diagram showing a format of an instruction in the case of mips.

FIG. 4 is a diagram showing name resolution processing by a mips instruction set.

FIG. 5 is a flowchart showing name resolution processing (instruction code rewriting processing) when a name is an object field and a value is loaded from the object field.

FIG. 6 is a diagram showing name resolution processing by a mips instruction set.

FIG. 7 is a flowchart showing name resolution processing (instruction code rewriting processing) when a name is an object field and a value is stored from the object field.

FIG. 8 is a diagram showing a name resolution process by a mips instruction set.

FIG. 9 is a diagram showing an instruction set before name resolution and an instruction set after name resolution when the name is a static address and the name is an object field.

FIG. 10 is a diagram showing necessary information for resolving a coded name.

FIG. 11 is a diagram showing instructions before and after name resolution when a value is loaded / stored from an object field.

FIG. 12 is a diagram showing a field load name resolution process in the case of mips.

FIG. 13 is a diagram showing a field store name resolution process in the case of mips.

FIG. 14 is a flowchart showing processing of a compiler.

FIG. 15 is a flowchart showing processing of a compiler.

FIG. 16 is a flowchart showing the processing of a compiler.

FIG. 17 is a diagram showing name resolution processing in the case of mips.

FIG. 18 is a flowchart showing a process of resolving a name reference of a plurality of field store access processes by a single name resolution process call.

FIG. 19 is a diagram showing name resolution processing in the case of mips.

FIG. 20 is a diagram showing, before and after name resolution, of an instruction code of a head access among object accesses for performing a name resolution process call;

FIG. 21 is a diagram showing before and after name resolution of an instruction code which is not the top access among object accesses for performing a name resolution process call.

FIG. 22 is a diagram showing an instruction set before name resolution and an instruction set after name resolution when loading and storing values of static variables.

FIG. 23 is a diagram showing an instruction set before name resolution and an instruction set after name resolution by a mips instruction when loading and storing the value of a static variable.

FIG. 24 is a diagram showing a part of a mips instruction set of a name resolution process when loading and storing a value of a static variable.

FIG. 25 is a diagram showing a part of a mips instruction set of a name resolution process when a value of a static variable is stored and when the value is stored.

FIG. 26 is a diagram showing a part of a mips instruction set of a name resolution process when a value of a static variable is stored and when the value is stored.

FIG. 27 is a view for explaining a conventional name resolution process.

FIG. 28 is a view for explaining a conventional name resolution process.

FIG. 29 is an exemplary view for explaining name resolution processing according to a procedure calling rule;

FIG. 30 is an exemplary view for explaining name resolution processing according to a procedure calling rule;

[Explanation of symbols]

1. Source program, 2. Compiler, 3. Execution program before name resolution, 4. Instruction code rewriting process, 5. Execution program after name resolution (after instruction code rewriting).

Claims (11)

[Claims] 1. A compiler for compiling a source program into an execution program, a name reference resolution call instruction for calling a name resolution procedure for resolving a name that can be resolved only at the time of execution of the program, and a resolution only at the time of execution of the program. Generating an instruction having no side effect and having a target register number for storing the resolved name; and generating the instruction having no side effect in the compiler. In the name resolution procedure called by the name reference resolution call instruction at the time of execution of the execution program, the name reference resolution call instruction and the instruction having no side effect are stored in a destination register based on the instruction having no side effect. Read name resolved value Instruction code rewriting method characterized by rewriting the writing instruction. 2. A compiler for compiling a source program into an execution program, a name reference resolution call instruction for calling a name resolution procedure for resolving the name of an object field that can be resolved only at the time of program execution, The compiler generates name identification information for identifying the name of the object field that can only be resolved, a target register number for storing the resolved name, and an instruction having no side effect having the base address of the object. Placing the generated instruction having no side effect in a delayed slot; and executing the execution program, in the name resolution procedure called by the name reference resolution call instruction, based on the instruction having no side effect. Instruction code rewriting method characterized by rewriting the free instructions irradiation resolve call instruction and said side effect, reads data of the address obtained by adding the name resolution value to the base address of the object into the destination register instruction. 3. A compiler for compiling a source program into an execution program, a name reference resolution call instruction for calling a name resolution procedure for resolving a name that can be resolved only at the time of program execution, an object base address, and the program Generates name identification information for identifying a name that can be resolved only at the time of execution, and an instruction without a side effect having a register number that holds a value to be stored in an object field. An instruction is arranged in a delayed slot, and in executing the execution program, in the name resolution procedure called by the name reference resolution call instruction, the name reference resolution call instruction and the side effect free Decree the instruction code rewriting method characterized by rewriting the values held in the register of the register number in the instruction to store to the address obtained by adding the value name resolution base address of said object. 4. The method according to claim 1, wherein the compiler analyzes a precedence relationship of the object field access, and the name resolution procedure resolves a plurality of names based on a result of the precedence analysis performed by the compiler. An instruction code rewriting method according to claim 2 or claim 3. 5. A compiler for compiling a source program into an execution program, a name reference resolution call instruction for calling a name resolution procedure for resolving a name that can be resolved only at the time of program execution, and a resolution only at the time of program execution. An instruction for generating name identification information for identifying a name that cannot be executed and an instruction having no side effect having a target register number for storing the resolved name, and placing the generated instruction having no side effect in a delayed slot. Code generating means, and in executing the execution program, in the name resolution procedure called by the name reference resolution call instruction, the name reference resolution call instruction and the instruction having no side effect based on the instruction having no side effect. Stores the value resolved to Instruction code rewriting device characterized by comprising a rewriting means for rewriting the instruction to be. 6. A compiler for compiling a source program into an execution program, a name reference resolution call instruction for calling a name resolution procedure for resolving the name of an object field that can be resolved only at the time of program execution, The compiler generates name identification information for identifying the name of an object field that can only be resolved, a target register number for storing the resolved name, and an instruction having no side effect having a base address of the object. Instruction code generating means for arranging the generated instruction having no side effect in the delayed slot; and executing the instruction having no side effect in the name resolution procedure called by the name reference resolution call instruction when the execution program is executed. Rewriting means for rewriting the name reference resolution call instruction and the instruction having no side effect into an instruction for loading data of an address obtained by adding a name resolved value to an object base address to a target register based on An instruction code rewriting device characterized by the above-mentioned. 7. A compiler for compiling a source program into an execution program, a name reference resolution call instruction for calling a name resolution procedure for resolving a name that can be resolved only at the time of program execution, an object base address, and the program The compiler generates name identification information for identifying a name that can be resolved only at the time of execution, and an instruction without a side effect having a register number holding a value to be stored in an object field. Instruction code generating means for arranging an instruction in a delayed slot; and executing a name reference resolution call instruction based on the instruction having no side effect in a name resolution procedure called by the name reference resolution call instruction when executing the execution program. And instruction code rewriting means for rewriting the instruction having no side effect to an instruction for storing a value held in the register of the register number to an address obtained by adding a value obtained by resolving a name to a base address of the object. An instruction code rewriting device characterized by the above-mentioned. 8. A compiler for compiling a source program into an execution program, a name reference resolution call instruction for calling a name resolution procedure for resolving a name that can be resolved only at the time of program execution, and a resolution only at the time of program execution. An instruction for generating name identification information for identifying a name that cannot be executed and an instruction having no side effect having a target register number for storing the resolved name, and placing the generated instruction having no side effect in a delayed slot. Code generating means, and in executing the execution program, in the name resolution procedure called by the name reference resolution call instruction, the name reference resolution call instruction and the instruction having no side effect based on the instruction having no side effect. Stores the value resolved to Computer-readable information recording medium storing a program and a rewriting means for rewriting the instruction to be. 9. A compiler for compiling a source program into an execution program, a name reference resolution call instruction for calling a name resolution procedure for resolving the name of an object field that can be resolved only at the time of program execution, The compiler generates name identification information for identifying the name of an object field that can only be resolved, a target register number for storing the resolved name, and an instruction having no side effect having a base address of the object. Instruction code generating means for arranging the generated instruction having no side effect in the delayed slot; and executing the instruction having no side effect in the name resolution procedure called by the name reference resolution call instruction when the execution program is executed. Rewriting means for rewriting the name reference resolution call instruction and the instruction having no side effect to an instruction for loading data of an address obtained by adding a name resolved value to an object base address to a target register based on A computer-readable information recording medium on which is recorded. 10. A compiler for compiling a source program into an execution program, a name reference resolution call instruction for calling a name resolution procedure for resolving a name that can be resolved only when the program is executed,
The compiler generates a base address of an object, name identification information for identifying a name that can be resolved only at the time of execution of the program, and an instruction having no side effect having a register number for holding a value to be stored in an object field. An instruction code generating means for arranging the generated instruction having no side effect in the delayed slot; and, during execution of the execution program, in a name resolution procedure called by the name reference resolution call instruction, based on the instruction having no side effect, Instruction code rewriting for rewriting the name reference resolution call instruction and the instruction having no side effect to an instruction for storing a value held in a register of the register number to an address obtained by adding a value obtained by resolving a name to a base address of the object With means A computer-readable information recording medium on which a program to be recorded is recorded. 11. The method according to claim 11, wherein the compiler analyzes a precedence relationship of an object field access, and the name resolution procedure resolves a plurality of names based on a result of the precedence analysis performed by the compiler. 9
Or the information recording medium according to claim 10.