JP3495230B2 - Emulation processing method - Google Patents

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a software emulation processing method, and more particularly to a software emulation processing method for executing application software developed for an arbitrary microprogram on another microprocessor having a different architecture. Regarding

[0002]

2. Description of the Related Art FIG. 2 is a block diagram showing a configuration of a system for executing a conventional emulation processing method of this type. A system that executes a conventional emulation processing system is an application program 201 created by machine language instruction codes of different architectures.
An emulator 202 that executes an application program on a target machine, and an address / target code storage table 203 that stores the target code converted by the emulator 202 together with the address in the application program.

The emulator 202 includes a program loading means 20201, an initial address setting means 20202, an address searching means 20203, and an address matching determining means 20.
204, application code extracting means 2020
5, application code-target code conversion means 20206, address / target code storage means 2
0207, target code executing means 20208, address updating means 20209, target code extracting means 2
0210 is included. The address / target code storage table 203 is stored in the memory of the target machine.

Next, the operation flow of the emulator 202 will be described with reference to the flowchart of FIG. The operation flow of the emulator 202 is the program loading means 3 of FIG.
01, initial address setting means 302, address searching means 303, address coincidence judging means 304, application code extracting means 305, application code-target code converting means 306, address / target code storing means 307, target code executing means 308, address updating It is composed of means 309, target code extracting means 310, and target code executing means 311.

First, the emulator 202 of FIG. 2 loads the application program 201 into the memory on the target machine by the program loading means 301 of FIG. 3, and the initial address setting means 302 sets the address at which the analysis is started to the start address of the application program. Set to. Next, by the address search means 303,
The address / target code storage table 203 is searched for an address to be analyzed. The address to be analyzed is the address / target code storage table 20.
If it is not 3, the application code fetching means 305 is executed via the address matching judgment means 304, but if there is a matching address, the target code fetching means 310 is executed.

Application code fetching means 30
5 retrieves one instruction of the application program of the address for executing the analysis, and
The target code conversion means 306 is performed. The application code-target code conversion means 306 converts the fetched application code into a target code and executes the address / target code storage means 307. The address / target code storage means 307
The address executing the analysis and the converted target code are stored in the address / target code storage table 203, and the target code executing means 308 is executed. The target code executing means 308 executes the converted target code to perform the address updating means 309. The address updating unit 309 updates the address according to the type or length of the emulated application code and performs the address searching unit 303.

Further, the target code extracting means 310
Executes the target code execution means 311 by fetching the target code corresponding to the address from the address / target code storage table 203. The target code executing means 311 executes the fetched target code to perform the address updating means 309.

As a concrete example, the operation of the emulator 202 of FIG. 2 when the application program shown in FIG. 4 is input will be described. In the application program of FIG. 4, the code “mov r1,1000h” at addresses 100h to 101h is the register r1.
Is an instruction to put 1000h in, and 102h-103h
The address code "mov [80000h], 10h" is an instruction to put 10h in the data area 80000h, and it is assumed that there is an instruction other than the branch instruction up to addresses 104h-off7h. The code "dec r1" at the addresses off8h-off9h is an instruction for decrementing the value of the register r1, and the code "c" at the addresses offah-offbh.
mp r1 , 0 ”is an instruction for comparing the registers r1 and 0 and setting the carry flag to 1 if r1 = 0 and setting the carry flag to 0 otherwise. Also offch-
Code of offdh address "brnc! 102h ”is an instruction for branching to the address 102h when the carry flag is 0, and a code“ re ”at the address offeh-offfh.
"t" is an instruction to return from the subroutine call, and here it is assumed that the nest of the subroutine call is 0 and the instruction ends the program.

In the example of FIG. 4, among the above instructions, "mov
Only [80000h], 10h ”has no instruction that can correspond one-to-one with the target host.
ver7, 10h ”,“ mov [80000h], r
7 ”and other instructions are converted to equivalent instructions. However, even though the instructions are converted into equivalent instructions, the equivalent instructions in the instruction set of the application code and the instruction set of the target code are not realized as the same binary code because they are realized by different binary codes.
Further, each instruction length in the target code is assumed to be 2 bytes.

Next, the operation will be described. First, the program loading means 301 in FIG. 3 loads an application program onto the memory of the target machine. Next, the initial address setting means 302 sets the starting address to the start address 100h of the emulation program. Next, the address search means 303 searches the address / target code storage table for the address 100h to be analyzed. Since the address 100h is not in the address / target code storage table, the application code fetching means 305 is executed. The application code extracting means 305
One instruction is fetched from the application program at the address 100h for executing the analysis. Therefore the address 100
Application code “mov r1,10” at address h
00h ”is taken out. The next application code-target code conversion means 306 converts the application code “mov r1,1000h” into the target code “movr1,1000h”.

The next address / target code storage means 307 stores the application address 100h and the target code "mov r1, 1000h" in the address / target code storage table. Next, the target code execution means 308 executes the target code “mov r1,1000h”. By executing the target code, the value of register r1 is 1000h.
become. After the execution, the address retrieving process 303 is performed with the address to be analyzed by the address updating unit 309 as the address 102h. The above operation is repeated of
The process is executed up to "dec r1" at the address f8h-off9h.

Since the value of the register r1 is 1000h, o
With the application code "dec r1" at the address ff8h-off9h, the register r1 becomes offffh, and at the application code "cmp r1,0" at the address offah-offbh, the carry flag becomes 0 because r1 = 0 is not satisfied, and offch- Application code of offdh address "brnc! Since the carry flag of "102h" is 0, the address for executing the analysis is the address 102h. The address / target code storage table at this time is shown in FIG.

After that, in the address search processing 303, the address / target code storage table is searched for the address 102h to be analyzed. Address 102
Since the address h is in the address / target code storage table, the target code extracting means 310 is executed. The target code extracting means 310 uses the target code “mov r7, 10h”, “mo” corresponding to the address from the address / target code storage table.
v [800000h], r7 ”is taken out. The next target code execution means 311 uses the target code “mo
v r7,10h ”,“ mov [800000h], r
7 ”to execute the address updating means 309. After that, the address to be analyzed by the address updating unit 309 is set to the address 104h, and the address search processing 30 is performed.
Execute 3. The above operations are repeated offch-
Off-street address "brnc! Up to 102h ”, the address to be analyzed again becomes the address 102h. At this time, the register r1 is offeh.

Further, the application code "dec
r1 ”,“ cmp r1,0 ”,“ brnc! 102
"h" performs the operation of decrementing the value of the register r1 by -1 and performing the address 102h if r1 = 0 is not satisfied. Therefore, from the address 102h to the address offdh, the register r "
The operation is repeated until the value of 1 becomes 0. Through the above-described repeated processing, the operations from the address 102h to the address offdh are repeated offeh times. After that, in the address search processing 303, the address / offeh address to be analyzed is searched from the address / target code storage table. Since the address offeh is not in the address / target code storage table, the application code fetching means 305 is executed.

Application code fetching means 30
Reference numeral 5 retrieves the application code "ret" at the address offeh. The application code-target code conversion means 306 converts the application code "ret" into the target code "ret". The address / target code storage means 307 stores the application address offseth address and the target code “ret” in the address / target code storage table. Next, target code execution means 308
Executes the target code "ret". Execution of the target code “ret” terminates the emulation means 202. The final address / target code storage table at this time is shown in FIG.

[0016]

In the conventional emulation processing method as described above, in the second and subsequent executions of the machine language code at the same address, the address searching means, the address matching means, and the target for each machine language instruction. Since the code fetching means is executed, it takes a long time to execute the emulation.

A specific example will be described with reference to the application program shown in FIG. In this example, it is assumed that the application code 1 instruction is replaced with the target code 2 instruction and the execution of the target code 1 instruction is 1 μs. In addition, “303 → 304” in FIG.
→ 305 → 306 → 307 → 308 → 309 ”has an average of 200 instructions other than the target code and 50 instructions of“ 303 → 304 → 310 → 311 → 309 ”other than the target code shown in FIG.

The time required for execution by the conventional method is "time required for first execution of machine language code" + "time required for second and subsequent execution of machine language code". In the conventional emulation processing method, the time required for the first execution of the machine language code is 1 (times) x (200 (instructions) + 2
(Instruction)) × ofooh (instruction) × 1 (μs) = 1
(Times) x (200 (commands) + 2 (commands)) x 3840
(Instruction) × 1 (μs) = 0.76 (seconds). Also, the time required for the second execution of the machine language code is (4
096 (times) x (50 (commands) + 2 (commands)) x ofo
oh (command) × 1 (μs) = (4096 (times) × (50
(Instruction) + 2 (instruction) x 3840 (instruction) x 1 (μ
s) = 8178.889 (seconds). Therefore, the time required to execute emulation processing by the conventional method is 0.7
76 (seconds) + 817.889 (seconds) = 818.665
(Seconds).

The present invention has been made to solve the above problems, and an object thereof is to provide an emulation processing system capable of high-speed processing.

[0020]

[0021]

The emulation of the present invention
In an emulation processing system that executes application software developed for an arbitrary microprogram on a host machine having a different architecture, the emulator processing system stores an application address / target address stored in a memory of the host machine. An emulation processing system is configured by the table, the target code storage table, the undecided reference information table, and the start address storage area, and the emulator includes a program loading unit that loads an emulation target application program into the memory of the host machine, and the start unit. Initial address setting means for setting the start address of the application program in the address storage area, and the application address / target The Ttoadoresu storage table, by the address to be executed of the emulated program to determine whether it is stored,
Application code conversion determination means for determining whether or not the machine language code of the emulation target program at the address is converted, and the emulation target program is set to a fixed value when the application address is not stored by the application code conversion determination means. The conversion start / end position setting means for setting the conversion start address and the conversion end address of the emulation target program in order to convert the machine language code of the host machine in byte units, and the address to execute the conversion of the emulation target program and application termination address determining means for determining whether the conversion end address, an address to be executed by the application termination address determining means is not the end of conversion address Means extraction application code to retrieve the machine code of the address from the emulated program when constant, a machine language code is a branch instruction emulated program taken out by the application code extraction means, reference destination address is the A branch instruction determination means for determining whether or not the value is not in the application address / target address storage table and is larger than the conversion end address, and the reference address of the branch instruction by the branch instruction determination means is the application address. / If it is not found in the target address storage table and the value is not equal to or larger than the conversion end address, the machine language code extracted from the emulation target program is Application code into a machine language code Tomashin - the target code conversion means, and stores the machine code of the host machine to the target code storage table, the machine code of the relevant address host machine of the emulated program The address of the host machine under analysis is stored in the application address / target address storage table together with the corresponding address, and when the reference destination of the machine language code is not in the application address / target address storage table, the undecided reference information table is analyzed. Address / target code storage means for storing together with the address of the emulation target program of the reference destination, target code execution means for executing the machine language code in the target code address, and When the branch instruction determination means determines that the reference address in the branch instruction is not in the application address / target address storage table and the value is equal to or larger than the conversion end address, or the end application address determination By the means, when the address to be executed is the conversion end address,
The control target code generation means for generating the machine language code of the host machine to return the control from the execution of the machine language code in the target code address to the emulation, and the undetermined value stored by the address / target code storage means. A reference destination determining means for changing the machine language code at the address of the host machine under analysis of the reference information table with the address of the machine language code of the host machine corresponding to the address of the emulation target program of the reference destination is provided. Is characterized by.

Further, in an emulation processing system for executing application software developed for an arbitrary microprogram on a host machine having a different architecture, an emulator and an application address / target address storage stored in the memory of the host machine. table, target code storage table, pending reference information table, the emulation processing system is composed of a start address storage area, loading program for loading the emulator, the emulation target application program in the memory of the host machine, said start address An initial address setting program that sets the start address of the application program in the storage area, and the application address / target Application for determining whether or not the machine language code of the emulation target program at the address is converted by determining whether or not the address to be executed by the emulation target program is stored in the address storage table. Code conversion determination program, start conversion of the emulation target program in order to convert the emulation target program into the machine language code of the host machine in constant byte units when the application address is not stored by the application code conversion determination program A conversion start / end position setting program for setting an address and a conversion end address, whether or not the address to be converted of the emulation target program is the conversion end address Application termination address determination program determines, determined address to be executed is not the conversion end address by the application termination address determination program
Is the emulation application code from the target program takes out the machine code of the address extraction program in machine language code branch instruction emulated program taken out by the application code extraction program, reference destination address is the application address when the / A branch instruction determination program that determines whether or not the value is not in the target address storage table and is greater than the conversion end address, and the reference address in the branch instruction is the application address / target address according to the branch instruction determination program. The machine extracted from the emulation target program when it is not found in the storage table and its value is not judged to be equal to or larger than the conversion end address. Application code to convert the code into machine code of the host machine - the target code converter, stores the machine code of the host machine to the target code storage table, the corresponding address of the emulated program of the host machine machine A host machine which is stored in the application address / target address storage table together with the corresponding address of the word code and is being analyzed in the undecided reference information table when the reference destination of the machine language code is not in the application address / target address storage table. Address / target code storing program for storing the address of the target code together with the address of the emulation target program of the reference destination, and a target for executing the machine language code in the target code address. When the branch code execution program and the branch instruction determination program determine that the reference address in the branch instruction is not in the application address / target address storage table and the value is equal to or greater than the conversion end address, or A control for generating a machine language code of the host machine for returning control from execution of the machine language code in the target code address to the emulation when the address to be executed is the conversion end address by the end application address determination program. The target language code at the address of the host machine under analysis of the stored undecided reference information table by the target code generation program for A reference destination determining program for changing at the address of the machine language code of the host machine corresponding to the address of the target program, and a recording medium having the respective programs recorded therein.

Further, the constant byte unit for converting the emulation target application program into the target code operating on the host machine is 1000 h.
It is characterized by being a bite.

With the emulation processing method of the present invention having the above-described configuration, high-speed replacement processing can be performed. That is, in the conventional emulation processing method, it is necessary to read the machine language, interpret and execute the machine language, and also to read and interpret the machine language instruction of the same part that was previously processed for each loop processing part. Further, even in the method described as the conventional technique, in which the code that has been executed once is speeded up when it is re-executed, there is execution of a code other than the execution target code for each instruction, and therefore it takes extra time. In the emulation processing method of the present invention, in consideration of the fact that the application program has a forward reference instruction, in the configuration as described above, the block program is read in and then replaced with the target program. Is possible.

[0025]

DETAILED DESCRIPTION OF THE INVENTION Embodiments of the present invention will be described below with reference to the drawings. FIG. 1 is a block diagram showing the configuration of a system for executing the simulation processing method of this embodiment. The system shown in FIG. 1 includes an application program 101 created by machine language instruction codes of different architectures, and an emulator 1 for executing this application program 101 on a target machine.
02 and the address in the application program 101 (application address 1031) to the address in the target program (target address 103
2) The application address / target address storage table 103 to be stored together with the emulator 10
The target code storage table 104 for storing the target code 1041 converted by 2 and the undecided reference information table 105 for storing the target address 10512 of the forward reference instruction together with the application address 10511 of the reference destination of the forward reference branch instruction are analyzed. It comprises a start address storage area 106 for storing the start address.

The emulator 102 includes a program load means 10201, an initial address setting means 10202, an application code conversion determination means 10203, a conversion start / end position setting means 10204, an end application address determination means 10205, an application code fetching means 10206, and a branch instruction determination. Means 1020
7, application code-target code conversion means 10208, address / target code storage means 1
0209, target code execution means 10210, control target code generation means 10211, and reference destination determination means 10212 are included. Application address / target address storage table 103,
The target code storage table 104, the undetermined reference information table 105, and the start address storage area 106 are
Stored in the memory of the target machine.

Next, the operation flow of the emulator 102 of this embodiment will be described with reference to the flowchart of FIG.
The operation flow of the emulator 102 is as follows: program load means 601, initial address setting means 602, application code conversion determining means 603, conversion start / end position setting means 604, end application address determining means 605, application code fetching means 606 of FIG. Branch instruction determination means 607, application code-target code conversion means 608, address / target code storage means 609, target code execution means 610, control target code generation means 611,
The address / target code storage unit 612, the control target code generation unit 613, the target code storage unit 614, and the reference destination determination unit 615 are included.

First, the emulator 102 of FIG. 1 loads the application program onto the memory of the target machine by the program loading means 601 of FIG. 6, and the initial address setting means 602 causes the application program to be stored in the start address storage area 106 of FIG. Set the start address of. Next, the application code conversion determination means 603 is performed. The application code conversion determination unit 603 determines whether or not the application address being analyzed is already converted depending on whether or not the application address being analyzed is in the application address / target address storage table 103 of FIG.

If there is an application address being analyzed, it is judged that it has already been converted, and the target code executing means 610 is executed. If there is no application address being analyzed, it is judged that it has not been converted. , Conversion start / end position setting means 604. The conversion start / end position setting means 604 sets the address fetched from the start address storage area 106 of FIG. 1 as the application address for starting the analysis. Then the application address from the start the application address to a certain byte size, if the application address / target address storing table 103 in FIG. 1, the application termination address larger applications address of which the most value.

If not, an application address of a fixed byte size is given from the start application address,
As the end application address, the end application address determination means 605 is performed. If the application address being analyzed is the end application address, the end application address determination means 605 executes the control target code generation means 613,
Otherwise, application code fetching means 6
Perform 06. Application code fetching means 60
6 fetches one instruction of the application program having the application address for executing the analysis, and executes the branch instruction judgment means 607.

The branch instruction determining means 607 determines that the fetched application code is a branch instruction, the referenced application address is not in the application address / target address storage table 103 of FIG. 1, and the value is equal to or larger than the end application address. That is, that is, it is determined that the instruction is a forward reference branch instruction out of the processing range that has not been completed, and the control target code generation means 611 is executed, and otherwise, the application code-target code conversion means 608 is executed. Application code-target code conversion means 608
Converts the fetched application code into a target code and executes the address / target code storage means 609.

Address / target code storage means 60
9 stores the application address being analyzed and the target address corresponding to the application address in the application address / target code address storage table 103 of FIG. 1, and converts the converted target code to the target address of FIG. Store in the target code storage table 104. Next, when the application code being analyzed is a branch instruction and the reference destination application address is not in the application address / target address storage table 103 of FIG. 1, the target code address being analyzed together with the reference destination application address is undetermined. Store in the reference information table 105.

Next, the application address to be analyzed is increased by the code size of the fetched application code, the target address corresponding to the application address is increased by the code size of the target code, and the end application address determining means 60.
Do 5. The control target code generation means 611 is
After the application address of the reference destination is stored in the start address storage area 106 of FIG. 1, a target code for returning control to the emulator is generated and the address / target code storage means 612 is executed. The address / target code storage means 612 stores the application address being analyzed and the target address corresponding to the application address in the application address / target code address storage table 103 of FIG.

Next, the generated target code is stored in the target code storage table of FIG. 1, the application address for analysis is increased by the code size of the fetched application code, and the target address corresponding to the application address is The code size of the target code is increased and the end application address determination means 605 is performed. The control target code generation means 613 stores the application address being analyzed in the start address storage area 106 of FIG. 1, then generates a target code for returning control to the emulator, and executes the target code storage means 614. The target code storage means 614 stores the generated target code in the target code storage table 1 of FIG.
04, and the reference destination determining means 615 is executed. The reference destination determining unit 615 uses the undetermined reference information table 10 shown in FIG.
The target address corresponding to the application address stored in No. 5 is retrieved from the application address / target address storage table 103 of FIG. 1, and the retrieved target address is used to store the target address stored in the undetermined reference information table 105. The target code execution means 610 is executed by changing the target code 1041 of FIG. The target code execution means 610 executes the target code from the target address corresponding to the application address that started the conversion. After the target code execution is completed, the application code conversion determination means 603 is performed.

As a concrete example, the operation of the emulator 102 of FIG. 1 when the application program shown in FIG. 7 is input will be described. In the application program of FIG. 7, the code “mov [800000h], 10h” at addresses 100h-101h is an instruction to put 10h in the data area 80000h, 102
Code "brc!" at address h-103h 106h ”is an instruction for branching to the address 106h when the carry flag is 1, and the code“ brnc for the addresses 104h-105h.
!! 2100h ”is address 2 when the carry flag is 0.
Instruction to branch to address 100h, 10feh-10ffh
The address code "and r1,10h" is the register r1.
And 10h AND operation and put the result in r1 Code "or r" at addresses 2100h-2101h
1, r2 ”is an instruction 2100h-2101 for performing the or operation of the registers r1 and r2 and putting the result in r1.
The code "ret" at the address h is an instruction to return from the subroutine call, and here it is assumed that the nest of the subroutine call is 0 and the instruction ends the program.

Generally, "br! "0XXXXh" is an instruction that unconditionally branches to address 0XXXXh, and "brc!
0XXXXh ”means 0XXXX if the carry flag is 1.
An instruction to branch to address h, "benc! 0XXXX
If the carry flag is 0, "h" is an instruction to branch to address 0XXXXh. In this example, "m
ov [800000h], 10h ", multiple instructions" mov r7,10h "," mov [800000] "
h], r7 ″, and the other instructions are converted into equivalent instructions. It is assumed that each instruction length in the target code is 2 bytes. In this example, the constant unit to be converted in this method is 1000 h bytes.

With the target address of the start address storage area in FIG. 1 as address 0c00000h, the application address of the reference destination of the "br" instruction stores address 0XXXXh, and the target code for returning control to the emulator is "mov r7, 0XXXXh". , "Mov
[0c00000h], r7 ”, and“ br [0h] ”. "Mov r7,0XXXXh" is the register r7
Command to put the value 0XXXXh into "mov [0c00
000h], r7 ”is an instruction to put the value of the register r7 at the address 0c0000h, and“ br [0h] ”is an instruction to return the control to the emulator.

The target code for returning control to the emulator after the application address of the reference destination of the "brc" instruction stores address 0XXXXh is "0" when the target address at the beginning of the target code for returning control to the emulator is 0AAAAh. brnc! 0A
AAAh + 8h ”,“ mov r7, 0XXXXh ”,
"Mov [0c00000h], r7", "br [0
h] ”. "Brnc! 0AAAAh + 8h ”
If the carry flag is 0, the machine code "brnc
!! 0AAAh + 8h ”,“ mov r7, 0XXX
Xh ”,“ mov [0c00000h], r7 ”,“ b
Since the size of “r [0h]” is 8 bytes, the machine language code “brnc! 0AAAh + 8h ”,“ mov
r7,0XXXXh ”,“ mov [0c00000
h], r7 ”, and“ br [0h] ”, the instruction branches to the next machine language code. That is, the carry flag is 1
When branching with, the instruction is to control the emulator, otherwise execute the subsequent machine code.

The target code that returns control to the emulator after the application address of the reference destination of the "brnc" instruction stores address 0XXXXh is "brc! 0AAAAA
h + 8h ”,“ mov r7, 0XXXXh ”,“ mo
v [0c00000h], r7 ”and“ br [0h] ”. "Brc! 0AAAAh + 8h ”is a machine language code“ brc! 0AAAAA
h + 8h ”,“ mov r7, 0XXXXh ”,“ mo
Since the size of v [0c00000h], r7 ”and“ br [0h] ”is 8 bytes, the machine language code“ brc ”
!! 0AAAAh + 8h ”,“ mov r7, 0XXXX
h ”,“ mov [0c00000h], r7 ”,“ br
The instruction is to branch to the machine language code next to [0h]. In other words, when the carry flag is 0, the instruction is to return control to the emulator, and otherwise execute the subsequent machine language code.

Next, the operation will be described. First, the program loading means 601 in FIG. 6 loads an application program onto the memory of the target machine. Next, the address started by the initial address setting means 602 is set to the start address 100h of the application program in the start address storage area 106 of FIG. The next application code conversion determination means 603 determines whether or not there is an application address 100h being analyzed in the application address / target address storage table 103 of FIG. Since the application address 100h is not in the application address / target address storage table 103,
The conversion start / end position setting means 604 is performed.

Next, the exchange start / end position setting means 604
Is the address 100h fetched from the start address storage area 106 of FIG. 1 as an application address for starting analysis, and the application address from the start application address to a fixed byte size is the application address / target address storage table 103 of FIG. Since it does not exist, a fixed byte size 1000 from the starting application address 100h
The end application address determining unit 605 is performed next using the h-byte application address 1100h as the end application address.

End application address judging means 6
In 05, the application address 100h being analyzed is the end application address 1100.
Since it is not the address h, the application code extracting means 606 is executed. The application code fetching unit 606 fetches one instruction of the application program at the address 100h for executing the analysis. Application code "mov [80
0000h], 10h ”is taken out.

Next, the branch instruction determining means 607 uses the application code "mov [800000h], 10h".
However, since it is not a branch instruction, the application code-target code conversion means 608 is executed. The application code-target code conversion means 608 uses the application code “mov [800000h], 10
h ”is used as a plurality of target codes“ mov r7,10
h ”,“ mov [800000h], r7 ”.

Next, the application address / target address storing means 609 stores the application address 100h being analyzed and the target address 100 corresponding to the application address 100h as the application address / application address of FIG.
The target code “mov r7,10” stored in the target code address storage table 103 and exchanged
h ”and“ mov [800000h], r7 ”are stored in the target code storage table of FIG. 1, and the application address to be analyzed and the corresponding target address are updated to 102h address and 104h address, respectively.

Next, in the end application address judging means 605, the application address 102h being analyzed is the end application address 1
Since the address is not 100h, the application code extracting unit 606 is executed. The application code fetching unit 606 fetches one instruction of the application program at the address 102h for executing the analysis.
Application code at address 102h "br
c! 106h ”is taken out. Next, the branch instruction determining means 607 causes the application code “brc! 10
6h ”is a branch instruction, and the reference destination application address 106h is the application address of FIG.
Although it is not in the target address storage table 103, its value 106h is the end application address 1100h.
Since it is smaller, the application code-target code conversion means 608 is performed.

The application code-target code conversion means 608 uses the application code "brc".
!! 106h ”is the target code“ brc! 0h ”
Convert to. Address / target code storage means 60
9 is the application address 102 being analyzed
The address h and the target code address 104 corresponding to the application address 102h are stored in the application address / target code address storage table 103 of FIG. 1, and the converted target code “brc! 0h ”is stored in the target code storage table 104 of FIG. 1 and the reference destination application address 106h is the application address / target address storage table 10 of FIG.
Since it is not in 3, the target code address under analysis is 10
Application address 106h that refers to address 4h
The address is stored in the undetermined reference information table 105 of FIG. 1 together with the address, and the application address to be analyzed and the corresponding target address are updated to the address 104h and the address 106h, respectively.

Next, in the end application address judging means 605, the application address 104h being analyzed is the end application address 11
Since the address is not 00h, the application code fetching unit 606 is executed. The application code fetching unit 606 fetches one instruction of the application program at the address 104h for executing the analysis. Application code "brnc" at address 104h
!! 2100h ”is taken out.

Next, the branch instruction determining means 607 causes the application code "brnc! 2100h ”is a branch instruction, the referenced application address 2100h is not in the application address / target address storage table 103 of FIG. 1, and the value 2100h is larger than the end application address 1100h. Therefore, the control target code generation means 611 is set. To do. The control target code generation means 611 stores the reference destination application address 2100h in the start address storage area 106 of FIG. 1 and then returns the target code “brc! 10eh ”,“ m
ov r7, 2100h ”,“ mov [0c00000
h], r7 ”,“ br [0h] ”are generated and the address / target code storage means 612 is executed.

Address / target code storage means 61
2 is the application address 104 being analyzed
The address h and the target address 106h corresponding to the application address are stored in the application address / target code address storage table 103 of FIG.
rc! 10eh ”,“ mov r7, 2100h ”,
"Mov [0c00000h], r7", "br [0
h] ”is stored in the target code storage table of FIG. 1 and the code size of the application code for which the analysis is performed is increased by 2h bytes to address 106h. The target address corresponding to the application address is the code of the target code. The final application address determining means 605 is performed by increasing the size by 8 h bytes to make the address 10 eh. By repeating the above, "a" at the address 10feh-10ffh
nd r1, 10h ”.

After that, the end application address 1100h, which is being analyzed by the end application address determination means 605, is the end application address 1
Since the address is 100h, the control target code generation means 6
Do 13. Control target code generation means 613
Stores the application address 1100h, which is being analyzed, in the start address storage area 106 of FIG.
ov r7, 2100h ”,“ mov [0c00000
h], r7 ”, and“ br [0h] ”are generated, and the target code storage unit 614 is performed.

Next, the target code storage means 614
Generated target code "movr7,2100
h ”,“ mov [0c00000h], r7 ”,“ br
[0h] ”is the target code storage table 10 of FIG.
Store in 4. FIG. 8 shows the application address / target address storage table, target code storage table, undecided reference information table, and start address storage area at this time. Next, the reference destination determining means 615 is configured as shown in FIG.
Of the application address 106h stored in the undetermined reference table 105 of FIG. 1, and the target address 10eh corresponding to the application address 106h is retrieved from the application address / target address storage table 103 of FIG. The target code “brc!” Already stored in the target address 104h corresponding to the application address 106h stored in 105. 0h ”is replaced with“ brc! 10e
h ”.

Next, the target code executing means 610
The target code is executed from the target address 100h corresponding to the application address 100h that started the conversion. The target machine is the target code “brc!” Of the target address 106h-10dh. 10eh ”,“ mov r7, 2100
h ”,“ mov [0c00000h], r7 ”,“ b
Since the carry flag is 0 when executing r [0h] ”, the target machine uses the target code“ mov
r7, 2100h ”,“ mov [0c00000h],
r7 ”and“ br [0h] ”are executed, 2100h is stored in the target address 0c00000h of the start address storage area of FIG. 1, control is returned to the emulator, and the application code conversion determination means 603 is performed. Since the application address 2100h is not found in the application address / target address storage table 103 in FIG. 1, the application code conversion determining means 603 executes the application code conversion determining means 604.

The address 2100h fetched from the start address storage area 106 of FIG. 1 is used as an application address for starting analysis, and the application address from the start application address to a certain byte size is stored as the application address / target address storage of FIG. Since it is not in the table 103, the application address 3 of a fixed byte size 1000h bytes from the start application address 2100h
The end application address determination unit 605 is performed using the address 100h as the end application address.

Application address 2100h-3
As for the processing of the emulator up to 100h, "605 → 606 → 607 → 608 →" of FIG. 6 is performed in the same manner as above until the application address being analyzed becomes 3100h.
609 → 605 ”or“ 605 in FIG.
→ 606 → 607 → 611 → 612 → 606 ”. Application address is 3100h
Then, in the same manner as above, “613 → 614 → 61” in FIG.
5 → 610 ”is executed to execute the target code. FIG. 9 shows the application address / target address storage table, target code storage table, undecided reference information table, and start address storage area at this time. After that, the target code "ret" at the target address 2102h is executed, and the emulation ends. As described above, the emulation processing method of this embodiment can perform high-speed processing.

A specific example will be described using the application program shown in FIG. As described above, in this example, assuming that the application code 1 instruction is replaced with the target code 2 instruction, the execution of the target code 1 instruction is 1 μs. Furthermore, “603-604-605-606-607-608-” in FIG.
609 ”is executed 400 instructions on average. As described above, the time required for the emulation processing is “the time required for the first execution of the machine language code” + “the time required for the second and subsequent executions of the machine language code”, which is one of the machine language codes of this method. The time required for the second execution is 1 (times) × (400 (instruction) +2 (instruction)) × ofoo
h (command) x 1 (μs) = 1 (times) x (400 (command)
+2 (instruction) × 3840 (instruction) × 1 (μs) = 1.
It is 545 (seconds). Also, the time required for the second and subsequent executions of the machine language code is 4096 (times) x 2 (instructions) x ofohoh (instructions) x 1
(Μs) = 4096 (times) × 2 (instruction) × 3840 (instruction) × 1 (μs) = 31.457 (seconds). Therefore, the time required for execution with this method is 1.545 (seconds)
It becomes +31.457 (second) = 33.002 (second). The time required for execution in the conventional method of the same example is 818 . 8
Since it is 89 (seconds), the speed can be increased 24.8 times.

An average program example, for example, an average of 10 executions of application programs executed once
0 times, the application program is 100
With 00 instructions, the time required for execution by the conventional method is 1 time for execution of the machine language code.
(Times) x (200 (commands) + 2 (commands)) x 10000
(Instruction) × 1 (μs) = 2.02 (seconds), and the time required for the second and subsequent executions of the machine language code is 100
(Times) x (50 (commands) + 2 (commands)) x 10000
Since (instruction) × 1 (μs) = 52 seconds, the time required for execution by the conventional method is 2.02 (seconds) +52 (seconds) =
It becomes 54.02 (seconds). On the other hand, the time required for execution by this method is 1 (times) × (400 (instruction) +2 (instruction)) × 10
000 (command) x 1 (μs) = 4.02 (seconds),
The time required for the second and subsequent executions of the machine language code is 10
0 (times) × 2 (instructions) × 10000 (instructions) × 1 (μ
Since s) = 2 (seconds), the time required for execution by this method is “4.02 (seconds) +2 (seconds) = 6.02 (seconds), and it is possible to achieve 8.97 times speedup. Become.

[0057]

As described above, according to the emulation processing method of the present invention, in consideration of the fact that the application program has the forward reference instruction, the target code for operating the emulation target application program in the host machine in constant units. Repeat the operation of executing the converted target code after converting to
In this conversion operation, if the emulation target application code is a branch instruction, and the reference destination is unsolved at the conversion stage and is outside the range to be converted, the target code that returns control from execution of the target code to the emulator is generated. Since it is decided to convert to, there is an effect that processing can be performed at high speed.

[Brief description of drawings]

FIG. 1 is a block diagram showing an embodiment of a configuration of a system for executing an emulation processing method of the present invention.

FIG. 2 is a block diagram showing an example of a configuration of a system for executing a conventional emulation processing method.

FIG. 3 is a flowchart showing the operation of a conventional emulation processing method.

FIG. 4 is a diagram showing a specific example of an application program.

5 is a diagram for explaining an address / target code storage table shown in FIG. 2. FIG.

FIG. 6 is a flowchart showing the operation of the emulation processing method of this embodiment.

FIG. 7 is a diagram showing a specific example of an application program for explaining the present embodiment.

FIG. 8 is a diagram showing the contents of an application address / target address storage table, a target code storage table, an undecided reference information table, and a start address storage area for explaining the operation of the present embodiment.

FIG. 9 is a diagram showing the contents of an application address / target address storage table, a target code storage table, an undecided reference information table, and a start address storage area for explaining the operation of this embodiment.

[Explanation of symbols]

101, 201 Application programs 102, 202 Emulator 103 Application address / target address storage table 104 Target code storage table 105 Undetermined reference information table 106 Start address storage area 203 Address / target address storage table 601, 10201 Program loading means 602, 10202 Initial Address setting means 603, 10203 Application code conversion determining means 604, 10204 Conversion start / end position setting means 605, 10205 End application address determining means 606, 10206 Application code extracting means 607, 10207 Branch instruction determining means 608, 10208 Application code-target Code conversion means 609,612, 0209 Address / target code storage means 610,10210 target code execution unit 611,613,10211 control target code generation unit 614 target code storage means 615,10212 reference destination determining means

─────────────────────────────────────────────────── ─── Continuation of the front page (56) References JP-A-6-202877 (JP, A) JP-A-4-268928 (JP, A) JP-A-8-123697 (JP, A) JP-A-8- 305583 (JP, A) (58) Fields investigated (Int.Cl. ⁷ , DB name) G06F 9/44

Claims (3)

(57) [Claims] 1. In an emulation processing system for executing application software developed for an arbitrary microprogram on a host machine having a different architecture, an emulator and an application address / target address storage stored in a memory of the host machine. the table, the target code storage table, the pending reference information table, start address storage area emulator
And a program loading means for loading the emulation target application program into the memory of the host machine, an initial address setting means for setting the start address of the application program in the start address storage area, and By determining whether or not the address to be executed by the emulation target program is stored in the application address / target address storage table, it is determined whether or not the machine language code of the emulation target program at the address is converted. Application code conversion determining means for determining, and the emulator when the application address is not stored by the application code conversion determining means. A conversion start / end position setting means for setting a conversion start address and a conversion end address of the emulation target program in order to convert the target program into a machine language code of the host machine in a constant byte unit, and the emulation target program conversion and application termination address determining means for determining the address to be executed as to whether or not the conversion end address of the address to be executed by the application termination address determining means is not the end of conversion address
An application code fetching unit that fetches a machine language code of the address from the emulation target program when determined, a machine instruction code of the emulation target program fetched by the application code fetching unit is a branch instruction, and a reference destination address is the A branch instruction determining unit that determines whether the value is not in the application address / target address storage table and is larger than the conversion end address; and the branch instruction determining unit causes the reference address in the branch instruction to be the application address. / If it is not found in the target address storage table and it is not determined that the value is equal to or greater than the conversion end address, the machine language code extracted from the emulation target program is Sutomashin application code into a machine code - the target code converting means, the machine code of the host machine and stored in the target code storage table, machine code of the host machine to the appropriate address of the emulated program Stored in the application address / target address storage table together with the corresponding address of
Address / target code storage means for storing the address of the host machine being analyzed together with the address of the emulation target program of the reference destination in the undetermined reference information table when it is not in the target address storage table, and a machine language in the target code address The target code executing means for executing the code and the branch instruction determining means judge that the reference address in the branch instruction is not in the application address / target address storage table and the value is equal to or larger than the conversion end address. Control, or when the address to be executed is the conversion end address by the end application address determining means, control is performed from execution of the machine language code in the target code address to this emulation. A control target code generation means for generating a machine language code of the host machine for returning, and a machine language code at an address of the host machine under analysis of the undecided reference information table stored by the address / target code storage means. And a reference destination determining means for changing the address of the host machine's machine language code corresponding to the address of the emulation target program of the reference destination, and an emulation processing system characterized by the above-mentioned.
Mu . 2. An emulation processing system for executing application software developed for an arbitrary microprogram on a host machine having a different architecture, wherein an emulator and an application address / target address storage stored in a memory of the host machine. the table, the target code storage table, the pending reference information table, start address storage area emulator
Shon processing system is configured, the emulator load program to load the emulation target application program in the memory of the host machine, the initial address setting program for setting the start address of the application program to the start address storage area, the application address / By determining whether or not the address to be executed by the emulation target program is stored in the target address storage table, it is determined whether or not the machine language code of the emulation target program at the address is converted. An application code conversion determination program, the application code conversion determination program, when the application address is not stored by the application code conversion determination program Conversion start / end position setting program for setting the conversion start address and the conversion end address of the emulation target program in order to convert the target program into the machine language code of the host machine in a constant byte unit, the conversion of the emulation target program address to be run determines whether the conversion end address application termination address determination program, the emulated when an address to be executed is determined to the non-conversion end address by the application termination address determination program An application code fetching program that fetches the machine language code of the address from the program, and an emulation that is fetched by the application code fetching program A branch instruction determination program that determines whether the machine language code of the target program is a branch instruction, the reference address is not in the application address / target address storage table , and the value is greater than the conversion end address, the branch instruction The machine fetched from the emulation target program when the judgment program does not judge that the reference address is not in the application address / target address storage table by the branch instruction and its value is equal to or larger than the conversion end address. application code to convert a word code into machine code of the host machine - the target code converter, stores the machine code of the host machine to the target code storage table, the emulation And storing the corresponding address of the elephant program with the appropriate address of the machine code of the host machine to the application address / target address storing table referenced machine code is the application address /
An address / target code storage program that stores the address of the host machine being analyzed together with the address of the emulation target program of the reference destination in the undetermined reference information table when it is not in the target address storage table, and a machine language code in the target code address A target code execution program for executing the above, the branch instruction determination program determined that the reference address in the branch instruction is not in the application address / target address storage table and the value is equal to or greater than the conversion end address. At this time, or when the address to be executed by the end application address determination program is the conversion end address, execution of the machine language code in the target code address Control target code generation program for generating a machine language code of the host machine to return control to the computer, and the address / target code storage program stores the undetermined reference information table at the address of the host machine under analysis. The machine language code is configured by a reference destination determination program that changes the machine language code address of the host machine corresponding to the address of the emulation target program of the reference destination, and a recording medium recording the respective programs is provided. Characterized emulation processing method. 3. The emulation processing system according to claim 1, wherein a constant byte unit for converting the emulation target application program into a target code operating on the host machine is 1000 h bytes.