WO2000065440A2 - Exception handling method and apparatus for use in program code conversion - Google Patents
Exception handling method and apparatus for use in program code conversion Download PDFInfo
- Publication number
- WO2000065440A2 WO2000065440A2 PCT/GB2000/001439 GB0001439W WO0065440A2 WO 2000065440 A2 WO2000065440 A2 WO 2000065440A2 GB 0001439 W GB0001439 W GB 0001439W WO 0065440 A2 WO0065440 A2 WO 0065440A2
- Authority
- WO
- WIPO (PCT)
- Prior art keywords
- subject
- register
- code
- abstract
- locations
- Prior art date
Links
- 238000000034 method Methods 0.000 title claims abstract description 52
- 238000006243 chemical reaction Methods 0.000 title claims abstract description 6
- 238000013519 translation Methods 0.000 claims abstract description 34
- 238000013507 mapping Methods 0.000 claims description 20
- 238000004590 computer program Methods 0.000 claims description 6
- 230000006870 function Effects 0.000 abstract description 7
- 230000000694 effects Effects 0.000 description 3
- 230000003068 static effect Effects 0.000 description 3
- PWPJGUXAGUPAHP-UHFFFAOYSA-N lufenuron Chemical compound C1=C(Cl)C(OC(F)(F)C(C(F)(F)F)F)=CC(Cl)=C1NC(=O)NC(=O)C1=C(F)C=CC=C1F PWPJGUXAGUPAHP-UHFFFAOYSA-N 0.000 description 2
- 238000013459 approach Methods 0.000 description 1
- 230000003631 expected effect Effects 0.000 description 1
- 238000007689 inspection Methods 0.000 description 1
- 238000012545 processing Methods 0.000 description 1
- 230000004044 response Effects 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
- G06F9/3017—Runtime instruction translation, e.g. macros
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
- G06F9/38—Concurrent instruction execution, e.g. pipeline or look ahead
- G06F9/3861—Recovery, e.g. branch miss-prediction, exception handling
- G06F9/3863—Recovery, e.g. branch miss-prediction, exception handling using multiple copies of the architectural state, e.g. shadow registers
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/455—Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
- G06F9/45504—Abstract machines for programme code execution, e.g. Java virtual machine [JVM], interpreters, emulators
Definitions
- the present invention relates in general to the field of program code conversion for computer systems and in particular, but not exclusively, to the field of emulation using dynamic binary translation.
- a program for a computer takes several different forms. Typically a program is written first in a high- level language readily understood by a human programmer. The program is compiled from the high-level language into a low-level language more appropriate for control of a computer's processor and related components. However, in order for the processor to function, the program code must be provided in a machine-readable form that directs primitive operations of the processor such as loading, shifting, adding and storing operations. To run faster, some processors use an expanded set of instructions each of which represent a sequence of primitive instructions.
- An emulator allows program code written for a processor of a first type (a "subject” processor) to be run on a processor of a second type (a "target” or “host” processor) .
- One form of this emulation process is known as binary translation because executable binary code appropriate to the subject processor is translated into executable binary code appropriate to the target processor.
- the emulator When performing dynamic binary translation the emulator appears to the subject code as if the subject code were running on the appropriate subject processor.
- the emulator replicates the subject machine including, for example, registers of the subject processor, such that the emulator provides a virtual subject machine.
- the emulated registers are termed herein "abstract registers" and correspond to the set of registers of the subject processor used by the subject code.
- the emulator first translates a predetermined small section of the subject code into an intermediate representation which represents the instructions of the subject code in a generic format, optionally performs optimisation on the intermediate representation, and then translates the optimised intermediate representation into executable binary code for the target processor.
- the small section of subject code corresponds to a "basic block" which starts with a first instruction at a unique entry point and ends at a last instruction at an unique exit point.
- the last instruction of the block is a jump, call or branch instruction (conditional or unconditional) .
- An exception indicates that a condition has occurred which needs to be handled before processing can continue. This includes explicit exceptions performed as an instruction in the subject code (for example an exception is reported if the value of . one register is greater than the value of a second register) , and implicit exceptions which occur for example as a result of memory read or write operations to a memory page that is not currently available. In both cases the exception is desirably reported to an exception handler written in subject code.
- many subject machine architecture definitions require that the exception is reported on a boundary between subject code instructions, following a predetermined set of rules.
- the subject architecture definition may require that when the exception is reported, the effects of all previous subject instructions are complete, the exception points to the first instruction of the subject code which has not been executed and no effects from that subject instruction or any subsequent instruction have yet taken place.
- the architecture definition of a particular processor may have different rules for different types of exceptions.
- Exceptions can occur in response to execution of the translated target code on the target processor, and can occur during execution of the emulator code on the target processor, i.e. during translation.
- the state of the virtual subject processor represented by the emulator must be available to the subject exception handler, including the correct status of the registers of the subject processor.
- One approach to this problem is to return the virtual subject machine to the conditions that applied at entry into the section of code being translated or executed, i.e. by returning the virtual subject machine to the condition prevailing at the point of entry into the current block of subject code instructions being translated or executed.
- the exception handler can now step through the instructions of the block of source code individually in sequence until the instruction causing the exception is identified.
- US 5832205 (Kelly et al) discloses an emulator which uses a set of "working" registers during emulation of each section of subject code. The content of each of these working registers is copied to a set of "official" virtual subject registers at the end of the section of subject code, using ' a gated store buffer. Therefore, if an exception occurs during emulation of a section of subject code this will affect only the working registers and the condition of the virtual subject machine can be recovered from the "official" registers at the point of entry into that section of subject code.
- An aim of the present invention is to provide a method of representing subject registers in an emulator which allows exceptions to be accurately reported to a subject exception handler in accordance with the rules of the handler, whilst minimising overhead in the emulator. It is a further aim of the present invention to provide an emulation method and apparatus wherein subject registers are represented to allow accurate exception handling.
- a method of representing a subject register in an emulator comprising the steps of :
- one of the first or second locations holds a definitive value of the abstract register at entry into that section, whilst the other of the first or second locations holds a speculative current value of the abstract register for use during that section.
- the abstract re ⁇ ister is mapped to the alternate one of the first or second locations upon reaching the end of the section of subject code.
- the speculative version becomes definitive when it is determined that no exception has occurred in the section of subject code.
- the step of alternating mapping is performed only if the content of the speculative version of the abstract register has been updated during the predetermined section of subject code.
- the step (a) comprises the steps of: (al) providing a plurality of abstract registers each representing a register of the subject machine; (a2) mapping each of the plurality of abstract registers to either a respective one of a first set of locations or a respective one of a second set of locations within the target machine.
- the step (b) comprises alternating mapping for each of the abstract registers between the respective one of each of the first and second sets of locations.
- the first location and/or the second location is a memory location within the target machine.
- the first location and/or the second location is a register of the target machine.
- the method is for use with an emulator that performs .dynamic binary translation.
- the predetermined section of subject code represents one or more basic blocks of subject code.
- a method for use in handling exceptions by an emulator performing program code conversion between subject code suitable for a subject processor and target " code suitable for a target processor comprising the steps of providing at least one abstract register (X,Y) each representing a register of the subject processor; (b) mapping the or each abstract register to a corresponding pair of locations within the target processor; and (c) alternating mapping of the or each abstract register between a first of the pair of locations and a second of the pair of locations, such that for a predetermined section of subject code, one of the first or second locations holds a definitive value of the abstract register at entry into that section for use by the emulator during exception handling, whilst the other of the first or second locations holds a speculative current value of the abstract register for updating by the emulator during that section.
- an emulator method and an emulator apparatus for performing the method according to any statement herein also extends to a computer when programmed to perform the method according to any statement herein, to a computer program for performing the method according to any statement herein, and to a computer program product containing computer readable instructions for performing the method according to any .sta ement -herein.
- Figure 1 shows a typical prior art configuration for a subject processor
- Figure 2 shows a typical emulator using binary translation
- Figure 3 shows a configuration of an emulator using binary translation as may be employed in preferred embodiments of the present invention
- Figure 4 shows a preferred binary translation type emulator in use
- Figures 5 and 6 show example sets of abstract registers .
- FIG. 1 a typical prior art arrangement is shown illustrating the configuration of a subject machine wherein subject code 10 is executed directly on a subject processor 11.
- subject code is executable binary code.
- the subject code may be represented in any suitable language with intermediate layers (compilers, etc.) between the subject code 10 and the subject processor 11 as will be familiar to the skilled person.
- FIG. 2 a typical prior art configuration is shown to illustrate the use of a binary translation type emulator 20 as an intermediate layer enabling the subject code 10 to be executed by a target processor 31.
- the preferred embodiment of the present invention is particularly intended for use with an emulator 20 which performs dynamic binary translation of the subject code 10 into target code 30 executable on the target processor 31.
- the emulator 20 of the preferred embodiment is illustrated in more detail and comprises a front end 21, a core 22 and a back end 23.
- the front end 21 is configured specific to the subject processor 11 being emulated.
- the front end 21 translates instructions of the subject code 10 into a generic intermediate representation for each basic block of subject code.
- Each basic block suitably includes a sequential set of instructions between a first instruction representing a unique entry point and a last instruction at a unique exit point (such as a jump, call or branch instruction) .
- the emulator 20 selects a group block comprising two or more basic blocks chosen for code generation and optimisation as a single unit. Further, the emulator 20 supports iso- blocks representing the same basic block of subject code under different entry conditions .
- Each predetermined section of the subject code 10 results in a block of intermediate representation (an "IR block") .
- the core 22 optimises each IR block generated by the front end 21 by employing optimisation techniques which need not be described here in detail.
- the back end 23 takes optimised IR blocks from the core 22 and produces target code 30 executable by the target processor 31.
- a first predetermined section of the subject code 10 is identified such as a basic block 100 and translated by the emulator 20 running on the target processor 31 in a translation mode.
- the target processor 31 then executes the corresponding optimised and translated block 300 of target code 30.
- the preferred emulator 20 includes a plurality of abstract registers, suitably provided in the core 22 shown in Figure 3, which represent the physical registers that are used within the subject processor 11 to execute the subject code 10.
- the abstract registers define the state of the subject processor 11 being emulated by representing the expected effects of the subject code instructions on the registers of the subject processor.
- set A and set B two sets of abstract registers are provided, here labelled set A and set B.
- set A holds "definitive" values. That is, the registers of set A are defined to hold initial values which are known to be valid representing the expected content of the physical registers of the subject processor 11 being emulated.
- the second set of abstract registers in this example labelled set B, are initially defined to represent "speculative" values. That is, at initialisation the second set of abstract registers (set B) also hold the expected initial content of the physical registers of the subject processor 11, but the values in set B are not relied upon as being valid.
- the emulator 20 uses the speculative set of abstract registers (i.e., set B) such that the content is updated to show the expected state of the physical registers of the subject processor 11 after execution of the block 100 of subject code 10.
- set B the speculative set of abstract registers
- the content of the definitive set of abstract registers of (i.e., set A) remains unchanged.
- the emulator 20 readily recovers the condition of the subject registers upon entry into the block 100 using the abstract registers marked as holding definitive data (i.e., set A).
- the exception handler can now step through the instructions of the block 100 of the source code 10 in sequence until the instruction causing the exception is identified.
- the status of the abstract registers is updated after each instruction. Therefore, when the subject code instruction responsible for the exception is identified the condition of the virtual subject machine represented by the emulator are reported to the subject code exception handler according to the rules thereof.
- the subject code exception handler recovers the exception in accordance with the handling process and returns to a point in the subject code appropriate to the exception. For example, it is common that the exception handler returns the emulator to the next unexecuted instruction of the source code 10. The translation or execution process can then continue from that point.
- the registers in the set holding speculative values i.e., set B
- the registers in the set holding speculative values will have been updated to hold the expected content of the equivalent registers of the subject processor 11 being emulated at the end of the basic block 100 of subject code 10.
- the abstract registers of the first set i.e., set A
- the abstract registers of the second set i.e., set B
- the abstract registers of set B Since the block 100 has been successfully translated and executed, the abstract registers of set B are now defined as holding definitive values, and the abstract registers of set A are defined as holding speculative values .
- the abstract registers of set A and set B suitably form register pairs.
- Each register in set A has a corresponding partner register in set B.
- One of the pair holds the definitive value of that abstract register, whilst the other holds the speculative value.
- the definition of these two registers is reversed such that each register of the pair performs the opposite function during the next section of code. Alternating the function of the two registers of each register pair provides a simple and elegant method of maintaining the entry conditions for the current section of code.
- a first abstract register (Reg X A ) representing register X of the subject processor 11 contains the definitive value whilst a second abstract register (Reg X B ) contains the speculative value.
- the abstract registers are suitably held in memory locations and a working map for register X points to the location of the speculative version Reg X B .
- Reg Y in this example initially Reg Y A is definitive whilst Reg Y B is speculative.
- the mapping for the abstract registers is updated for step 2 as shown in Figure 6.
- the first read operation encountered during a current section of code uses the definitive version of each particular abstract register.
- the definitive version represents the condition of that register at entry into the current section of code and therefore maintains continuity with the previous section.
- Further read operations also use the definitive version of each abstract register, until a write operation is encountered.
- the first write operation uses the speculative version of each particular abstract register. Therefore the definitive version remains unchanged and the speculative version now contains the current value of the relevant abstract register. Subsequent read and write operations use the speculative version for the remainder of that section of code.
- an abstract register are provided corresponding to each physical register of the subject processor 11, with the abstract register being mapped to two predetermined locations.
- One of each pair of abstract register locations contains a definitive value whilst the other contains a speculative value.
- the function of these two locations is readily reversed to alternate the location holding definitive content. Therefore, time consuming copying operations are avoided.
- two versions of each of abstract register are achieved by mapping to two sets of memory locations and the definitive and speculative versions alternated by alternating the memory mapping between these two locations .
- Updating the map of the abstract registers held in the target machine to replicate the physical registers of the subject processor is performed .quickly and simply at translation time, and imposes no overhead when the translated code is executed, possibly many times.
- one or both of the definitive and speculative versions of the abstract registers may be stored in a pair of target machine registers (on a target machine with a sufficiency thereof) as an alternative to using a pair of memory locations.
- One aspect of the preferred embodiment of the present invention addresses the problem of fixing register references across branches, and in particular a branch (or loop) from a current block of subject code to a previously translated block. Branches between blocks of code are commonly encountered in practice, and often involve the same block of code being referenced from more than one other locations within the subject code, thereby generating different entry conditions.
- One solution is to copy the content from the definitive to the speculative version of the abstract register, such that the entry conditions are appropriate for use of the previously translated block of code.
- translating a section of subject code by one extra time eliminates the compensation copying that would have been necessary for any particular register that was updated an odd number of times in that loop.
- the embodiments described above refer to an emulator employing dynamic binary translation
- the method is also applicable to static translation where a large section of code is translated prior to execution.
- static translation the section of code selected for translation typically represents a whole program or a major part of a program.
- the method is applicable to program code optimisation wherein the subject machine and the target machine have the same or at least compatible instruction sets and architectures .
- the present invention extends to a computer when programmed to ⁇ perform the method described above, to a computer program for performing the method described above, and to a computer program product containing computer readable instructions for performing the method described above.
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Executing Machine-Instructions (AREA)
- Devices For Executing Special Programs (AREA)
Abstract
Description
Claims
Priority Applications (4)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
JP2000614118A JP4709394B2 (en) | 1999-04-27 | 2000-04-26 | Method and apparatus for exception handling used in program code conversion |
EP00927395A EP1183601A2 (en) | 1999-04-27 | 2000-04-26 | Exception handling method and apparatus for use in program code conversion |
AU45803/00A AU4580300A (en) | 1999-04-27 | 2000-04-26 | Exception handling method and apparatus for use in program code conversion |
US09/827,970 US7353163B2 (en) | 1999-04-27 | 2001-04-06 | Exception handling method and apparatus for use in program code conversion |
Applications Claiming Priority (4)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US29975199A | 1999-04-27 | 1999-04-27 | |
US09/299,751 | 1999-04-27 | ||
GB9909615.8 | 1999-04-27 | ||
GB9909615A GB2349486B (en) | 1999-04-27 | 1999-04-27 | Exception handling in program code conversion. |
Related Child Applications (2)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US09/827,970 Continuation-In-Part US7353163B2 (en) | 1999-04-27 | 2001-04-06 | Exception handling method and apparatus for use in program code conversion |
US09/827,970 Continuation US7353163B2 (en) | 1999-04-27 | 2001-04-06 | Exception handling method and apparatus for use in program code conversion |
Publications (2)
Publication Number | Publication Date |
---|---|
WO2000065440A2 true WO2000065440A2 (en) | 2000-11-02 |
WO2000065440A3 WO2000065440A3 (en) | 2001-01-25 |
Family
ID=26315473
Family Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
PCT/GB2000/001439 WO2000065440A2 (en) | 1999-04-27 | 2000-04-26 | Exception handling method and apparatus for use in program code conversion |
Country Status (4)
Country | Link |
---|---|
EP (1) | EP1183601A2 (en) |
JP (1) | JP4709394B2 (en) |
AU (1) | AU4580300A (en) |
WO (1) | WO2000065440A2 (en) |
Cited By (6)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
WO2002042898A2 (en) * | 2000-11-20 | 2002-05-30 | Zucotto Wireless, Inc. | Interpretation loop for object oriented processor |
WO2005006106A3 (en) * | 2003-07-04 | 2005-08-25 | Transitive Ltd | Method and apparatus for performing adjustable precision exception handling |
JP2008505423A (en) * | 2004-07-08 | 2008-02-21 | インテル コーポレイション | Generation of unwind information for optimized programs |
CN102141929A (en) * | 2010-10-21 | 2011-08-03 | 华为技术有限公司 | Application program running method, simulator, host machine and system |
US8381168B2 (en) | 2006-10-02 | 2013-02-19 | International Business Machines Corporation | Computer system and method of adapting a computer system to support a register window architecture |
US8543371B2 (en) | 2008-05-22 | 2013-09-24 | Fujitsu Limited | Write-protected storage medium, write-protected apparatus, and write-protected environment |
Families Citing this family (2)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
GB2401217B (en) * | 2003-05-02 | 2005-11-09 | Transitive Ltd | Improved architecture for generating intermediate representations for program code conversion |
WO2014043886A1 (en) * | 2012-09-21 | 2014-03-27 | Intel Corporation | Methods and systems for performing a binary translation |
Citations (3)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
EP0285310A2 (en) * | 1987-03-31 | 1988-10-05 | Kabushiki Kaisha Toshiba | Device for saving and restoring register information |
WO1998059292A1 (en) * | 1997-06-25 | 1998-12-30 | Transmeta Corporation | Improved microprocessor |
US5872950A (en) * | 1997-03-31 | 1999-02-16 | International Business Machines Corporation | Method and apparatus for managing register renaming including a wraparound array and an indication of rename entry ages |
Family Cites Families (9)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
JPS63156236A (en) * | 1986-12-19 | 1988-06-29 | Toshiba Corp | Register device |
JP2707867B2 (en) * | 1991-04-25 | 1998-02-04 | 富士ゼロックス株式会社 | Register file of digital computer and instruction execution method using it. |
JP3302706B2 (en) * | 1991-05-31 | 2002-07-15 | 日本電気株式会社 | Storage device |
JPH06180653A (en) * | 1992-10-02 | 1994-06-28 | Hudson Soft Co Ltd | Interruption processing method and device therefor |
US5694564A (en) * | 1993-01-04 | 1997-12-02 | Motorola, Inc. | Data processing system a method for performing register renaming having back-up capability |
JPH0756760A (en) * | 1993-08-10 | 1995-03-03 | Fujitsu Ltd | Recovery device |
JP2513142B2 (en) * | 1993-09-07 | 1996-07-03 | 日本電気株式会社 | Program simulator device |
US5812823A (en) * | 1996-01-02 | 1998-09-22 | International Business Machines Corporation | Method and system for performing an emulation context save and restore that is transparent to the operating system |
US5925124A (en) * | 1997-02-27 | 1999-07-20 | International Business Machines Corporation | Dynamic conversion between different instruction codes by recombination of instruction elements |
-
2000
- 2000-04-26 EP EP00927395A patent/EP1183601A2/en not_active Withdrawn
- 2000-04-26 WO PCT/GB2000/001439 patent/WO2000065440A2/en active Search and Examination
- 2000-04-26 JP JP2000614118A patent/JP4709394B2/en not_active Expired - Lifetime
- 2000-04-26 AU AU45803/00A patent/AU4580300A/en not_active Abandoned
Patent Citations (3)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
EP0285310A2 (en) * | 1987-03-31 | 1988-10-05 | Kabushiki Kaisha Toshiba | Device for saving and restoring register information |
US5872950A (en) * | 1997-03-31 | 1999-02-16 | International Business Machines Corporation | Method and apparatus for managing register renaming including a wraparound array and an indication of rename entry ages |
WO1998059292A1 (en) * | 1997-06-25 | 1998-12-30 | Transmeta Corporation | Improved microprocessor |
Cited By (10)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
WO2002042898A2 (en) * | 2000-11-20 | 2002-05-30 | Zucotto Wireless, Inc. | Interpretation loop for object oriented processor |
WO2002042898A3 (en) * | 2000-11-20 | 2004-03-04 | Zucotto Wireless Inc | Interpretation loop for object oriented processor |
WO2005006106A3 (en) * | 2003-07-04 | 2005-08-25 | Transitive Ltd | Method and apparatus for performing adjustable precision exception handling |
US7685579B2 (en) | 2003-07-04 | 2010-03-23 | International Business Machines Corporation | Method and apparatus for performing adjustable precision exception handling |
CN1813242B (en) * | 2003-07-04 | 2010-04-28 | 国际商业机器公司 | Method and apparatus for performing adjustable precision exception handling |
JP2008505423A (en) * | 2004-07-08 | 2008-02-21 | インテル コーポレイション | Generation of unwind information for optimized programs |
JP4833206B2 (en) * | 2004-07-08 | 2011-12-07 | インテル コーポレイション | Generation of unwind information for optimized programs |
US8381168B2 (en) | 2006-10-02 | 2013-02-19 | International Business Machines Corporation | Computer system and method of adapting a computer system to support a register window architecture |
US8543371B2 (en) | 2008-05-22 | 2013-09-24 | Fujitsu Limited | Write-protected storage medium, write-protected apparatus, and write-protected environment |
CN102141929A (en) * | 2010-10-21 | 2011-08-03 | 华为技术有限公司 | Application program running method, simulator, host machine and system |
Also Published As
Publication number | Publication date |
---|---|
WO2000065440A3 (en) | 2001-01-25 |
AU4580300A (en) | 2000-11-10 |
JP2002543490A (en) | 2002-12-17 |
JP4709394B2 (en) | 2011-06-22 |
EP1183601A2 (en) | 2002-03-06 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
JP3872809B2 (en) | Method and apparatus for enhancing scheduling in advanced microprocessors | |
CA2262928C (en) | Method and apparatus for aliasing memory data in an advanced microprocessor | |
US7716452B1 (en) | Translated memory protection apparatus for an advanced microprocessor | |
US5958061A (en) | Host microprocessor with apparatus for temporarily holding target processor state | |
US6247172B1 (en) | Method for a translation system that aggressively optimizes and preserves full synchronous exception state | |
US6031992A (en) | Combining hardware and software to provide an improved microprocessor | |
KR100463810B1 (en) | Memory controller for a microprocessor for detecting a failure of speculation on the physical nature of a component being addressed | |
JP3776132B2 (en) | Microprocessor improvements | |
US6519768B1 (en) | Instruction translation method | |
US5854928A (en) | Use of run-time code generation to create speculation recovery code in a computer system | |
EP1183601A2 (en) | Exception handling method and apparatus for use in program code conversion | |
US7353163B2 (en) | Exception handling method and apparatus for use in program code conversion | |
CA2283772C (en) | Host microprocessor with apparatus for temporarily holding target processor state | |
GB2349486A (en) | Exception handling in program code conversion | |
JP3324542B2 (en) | Virtual machine | |
EP1033651B1 (en) | Instruction translation method | |
EP1033650A2 (en) | Instruction translation method |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
AK | Designated states |
Kind code of ref document: A2 Designated state(s): AE AG AL AM AT AU AZ BA BB BG BR BY CA CH CN CR CU CZ DE DK DM DZ EE ES FI GB GD GE GH GM HR HU ID IL IN IS JP KE KG KP KR KZ LC LK LR LS LT LU LV MA MD MG MK MN MW MX NO NZ PL PT RO RU SD SE SG SI SK SL TJ TM TR TT TZ UA UG US UZ VN YU ZA ZW |
|
AL | Designated countries for regional patents |
Kind code of ref document: A2 Designated state(s): GH GM KE LS MW SD SL SZ TZ UG ZW AM AZ BY KG KZ MD RU TJ TM AT BE CH CY DE DK ES FI FR GB GR IE IT LU MC NL PT SE BF BJ CF CG CI CM GA GN GW ML MR NE SN TD TG |
|
121 | Ep: the epo has been informed by wipo that ep was designated in this application | ||
AK | Designated states |
Kind code of ref document: A3 Designated state(s): AE AG AL AM AT AU AZ BA BB BG BR BY CA CH CN CR CU CZ DE DK DM DZ EE ES FI GB GD GE GH GM HR HU ID IL IN IS JP KE KG KP KR KZ LC LK LR LS LT LU LV MA MD MG MK MN MW MX NO NZ PL PT RO RU SD SE SG SI SK SL TJ TM TR TT TZ UA UG US UZ VN YU ZA ZW |
|
AL | Designated countries for regional patents |
Kind code of ref document: A3 Designated state(s): GH GM KE LS MW SD SL SZ TZ UG ZW AM AZ BY KG KZ MD RU TJ TM AT BE CH CY DE DK ES FI FR GB GR IE IT LU MC NL PT SE BF BJ CF CG CI CM GA GN GW ML MR NE SN TD TG |
|
DFPE | Request for preliminary examination filed prior to expiration of 19th month from priority date (pct application filed before 20040101) | ||
WWE | Wipo information: entry into national phase |
Ref document number: 09827970 Country of ref document: US |
|
WWE | Wipo information: entry into national phase |
Ref document number: 2000927395 Country of ref document: EP |
|
ENP | Entry into the national phase in: |
Ref country code: JP Ref document number: 2000 614118 Kind code of ref document: A Format of ref document f/p: F |
|
REG | Reference to national code |
Ref country code: DE Ref legal event code: 8642 |
|
WWP | Wipo information: published in national office |
Ref document number: 2000927395 Country of ref document: EP |
|
DPE2 | Request for preliminary examination filed before expiration of 19th month from priority date (pct application filed from 20040101) |