International Business Machines Corporation

Transitive Limited

Gavin Barraclough

Kit Man Wan

ALexander B Brown

Gisle Dankel

Abdul Rahman Hummaida

Geraint M North

Paul Knowles

James Mulcahy

David N Mackintosh

David MacKintosh

Miles Philip Howson

Alex Brown

William Owen Lovett

Matthew Evans

David James Rigby

James Richard Henry Mulcahy

Execution control techniques are described for use in a translator that converts subject code into target code. The translator includes a translator trampoline function that is called from a translator run loop and which in turn calls either to a translator code generator to generate target code, or else calls previously generated target code for execution. Control then returns to the translator trampoline function to make a new call, or returns to the translator run loop. Other aspects include making context switches through the trampoline function and setting first and second calling conventions either side of the trampoline function. Jumping directly or indirectly between target code blocks during execution is also described.

Execution control during program code conversion

An execution control method is described for use in a translator () which converts subject code () into target code (). The translator () includes a translator trampoline function () which is called from a translator run loop () and which in turn calls either to a translator code generator () to generate target code, or else calls previously generated target code () for execution. Control then returns to the translator trampoline function () to make a new call, or returns to the translator run loop (). Other aspects include making context switches through the trampoline function () and setting first and second calling conventions either side of the trampoline function (). Jumping directly or indirectly between target code blocks () during execution is also described.

A target computing system performs program code conversion from subject code, executable by a subject computing architecture, into target code executable by the target computing system, and then executes the target code. The target system handles exceptions during binding to native code. Native code binding executes a portion of native code in place of translating a portion of the subject code into the target code. Upon an exception during execution of the portion of native code, the target system saves a target state representing a current point of execution for the portion of native code, and creates a subject state representing an emulated point of execution in the subject architecture. A subject exception handler handles the exception with reference to the subject state. Upon resuming execution from the exception using the subject state, the saved target state is restored to resume execution in the section of portion of native code.

Method and apparatus for handling exceptions during binding to native code

A computing system capable of handling floating point operations during program code conversion is described, comprising a processor including a floating point unit and an integer unit. The computing system further comprises a translator unit arranged to receive subject code instructions including at least one instruction relating to a floating point operation and in response to generate corresponding target code for execution on said processor. To handle floating point operations a floating point status unit and a floating point control unit are provided within the translator. These units are cause the translator unit to generate either: target code for performing the floating point operations directly on the floating point unit; or target code for performing the floating point operations indirectly, for example using a combination of the integer unit and the floating point unit. In this way the efficiency of the computing system is improved.

Handling floating point operations

Precise exception handling relies on a precise subject state including an accurate program counter and register values of a subject processor. Subject code () is translated into target code () executable by a target processor (). The generated target code () includes counterpart target instructions () associated with fault-vulnerable subject code instructions (). Further, each of the counterpart target code instruction () is associated with recovery information (). When an exception (e.g. a fault) occurs, the recovery information () is retrieved and used to recover a precise subject state, in particular by taking account of optimizations to generate the common-case target code (). The precise subject state is then used to precisely handle the exception.

Precise handling of exceptions during program code conversion

A dynamic binary translatorconverts a subject programinto target codeon a target processor. For a multi-threaded subject environment, the translatorprovides a global tokencommon to each thread, and one or more sets of local data, which together are employed to coordinate access to a memoryas a shared resource. Adjusting the global tokenallows the local datastructuresin each thread to detect potential interference with the shared resource

Converting program code with access coordination for a shared memory

A method and apparatus to protect memory consistency in a multiprocessor computing system are described, in particular relating to program code conversion such as dynamic binary translation. The exemplary system provides a memory, processors and a controller/translator unit (CTU) arranged to convert subject code into at least first and second target code portions executable on the processors. The CTU comprises an address space allocation unit to provide virtual address space regions and direct the target code portions to access the memory therethough; a shared memory detection unit to detect a request to access a shared memory area, accessible by both target code portions, and to identify at least one group of instructions in the first target code portion which access the shared memory area; and a memory protection unit to selectively apply memory consistency protection in relation to accesses to the shared memory area by the identified group of instructions.

Memory consistency protection in a multiprocessor computing system

A translator apparatus is provided with both program code interpreting and translating functionality, where subject program code is interpreted rather than being translated in those situations where interpretation of the subject program code is determined to be more beneficial. The translator applies an interpreting algorithm to determine whether a basic block of subject program code should be interpreted or translated. A particular subject of instructions supported by the interpreter functionality is initially selected from an entire instruction set for the subject program code. A basic block will be interpreted 1) if all of the instructions within a basic block are determined to be within the subset of instructions supported by the interpreter functionality, and 2) if an execution count of the basic block is below a translation threshold. If either of these two conditions are not satisfied, then the basic block is translated by the translator

Method and apparatus for performing interpreter optimizations during program code conversion

An improved method and apparatus for performing program code conversion is provided and, more particularly, for generating improved intermediate representations for use in program code conversion. During program code conversion, a partial dead code elimination optimization technique is implemented to identify partially dead register definitions within a block of program code being translated. The partial dead code elimination is an optimization to the intermediate representation in the form of code motion for blocks of program code ending in non-computed branches or computed jumps, where target code for all dead child nodes of a partially dead register definition is prevented from being generated and target code for partially dead child nodes of a partially dead register definition is delayed from being generated until after target code is generated for all fully live child nodes for the partially dead register definition.

Growing community of inventors

Manchester, United Kingdom

Gavin Barraclough