Compiler generating functionally-alike code sequences in an executable program intended for execution in different run-time environments

• US 5,920,721 A
• Filed: 06/11/1997
• Issued: 07/06/1999
• Est. Priority Date: 06/11/1997
• Status: Expired due to Term

• Current Assignee: Hewlett Packard Enterprise Development LP (Hewlett-Packard Enterprise Company)
• Original Assignee: Digital Equipment Corporation (HP Inc.)
• Inventors: Sites, Richard L., Hunter, David P., Van Baak, Thomas, Colgate, William K.
• Primary Examiner(s): Downs, Robert W.
• Assistant Examiner(s): ZHEN, WEI Y
• Application Number:
  US08/873,147
• Time in Patent Office: 755 Days
• Field of Search: 395/706, 395/500, 395/712, 395/800, 395/700, 395/300, 395/200, 395/705
• US Class Current: 717/159
• CPC Class Codes: G06F 8/47 Retargetable compilers

Abstract

A compiler-loader system enables the creation of different loaded executable images in target computers complying with different versions of an instruction-set architecture, the different images being created from a single executable program on secondary storage. The compiler generates an executable program containing a routine executable on both versions of the target computers, and also containing an architecture entry with (i) an address of the program location from which the routine is called, (ii) an instruction executable on only one version of the target computers that performs the same function as the routine but with superior performance, and (iii) a value indicating which version of the target machines the instruction can be executed on. The loader determines whether the target machine can execute the instruction, and if so replaces the subroutine call appearing at the address in the architecture entry with the instruction appearing in the architecture entry.

Claims

1. A method of generating an executable program, comprising the step of generating a plurality of code sequences in the executable program, each code sequence performing a common function required by a portion of a source program from which the executable program is generated, each code sequence being better suited for execution in a corresponding one of different run-time environments than are the other code sequences, the code sequences being generated in a manner enabling execution of the better-suited code sequence in each of the run-time environments.

2. A method according to claim 1, further comprising the step of generating the following information in the executable program:

(i) an address specifying a program location in the executable program at which the common function required by the portion of the source program is to be performed; and

(ii) for each code sequence performing the common function, a value indicating for which run-time environment the code sequence is better suited.

3. A method according to claim 1, wherein:

the one of the code sequences that is better suited for execution in a predetermined one of the run-time environments is generated in a manner providing for its default execution and for its ready identification by a cooperating entity in another of the run-time environments capable of modifying the executable program to provide for execution of another of the code sequences instead of the one code sequence; and

the other code sequences are generated in a manner providing for their ready identification by the cooperating entity.

4. A method according to claim 3, wherein the cooperating entity is a loader.

5. A method according to claim 1, wherein:

the different run-time environments are two different versions of computers on which the executable program is intended to be executed;

the number of code sequences generated to perform the common function is two;

one of the code sequences is an instruction that is executable on only one version of the computers; and

the other code sequence is a routine that is less efficient than the instruction during execution but is executable on both versions of the computers.

6. A method according to claim 5, wherein the two versions of the computers are distinguished by their compliance with two different versions of an instruction-set architecture, one version of the instruction-set architecture being a later version that is a superset of the other.

7. A method according to claim 5, wherein both versions of the computers have a 64-bit memory architecture, one of the code sequences is a byte store instruction, and the other code sequence is a multiple-instruction routine performing the byte store operation.

8. A method according to claim 1 wherein execution of the better-suited code sequence is enabled by modifying the executable program at run-time so that the better-suited code sequence is executed.

9. A method according to claim 8 wherein modifying the executable program further comprises patching the better-suited code sequence into the executable program.

10. A method according to claim 9 wherein patching is done by a loader program.

11. A method according to claim 1 wherein the different run-time environments are different operating systems.

12. A method according to claim 1 wherein the different run-time environments include normal operating mode and debugging mode.

13. A method according to claim 1 wherein the different run-time environments comprise different respective floating-point calculation methods.

14. A method according to claim 1 wherein the different run-time environments have different desired preciseness.

15. A method according to claim 1 further comprising:

generating code in the executable program, said generated code for patching in the better suited code sequence at run-time.

16. A method according to claim 1 wherein a code sequence is called from multiple locations within the executable program where the common function is required.

17. A method, comprising the steps of:

generating an instruction in an executable program, the instruction performing a function required by a portion of a source program from which the executable program is generated, the instruction being executable on only one of two different versions of computers on which the executable program is intended to be executed;

generating a routine in the executable program, the routine also performing the required function but being executable on both versions of the computers; and

generating an architecture entry in the executable program having (i) an address specifying a program location in the executable program at which the function is required to be performed; and

(ii) a value indicating which version of the computers can execute the instruction.

18. A method according to claim 17, wherein the routine is a subroutine callable from the program location specified by the address included in the architecture information, and wherein the instruction is included in the architecture entry, and further comprising the step of generating a call to the subroutine in the executable program at the specified program location, the subroutine call being generated in a manner enabling its subsequent replacement with the instruction without interference to the flow of execution of the remainder of the executable program.

19. A method according to claim 17, wherein both versions of the computers have a 64-bit memory architecture, and wherein the function performed by the instruction and the routine is storing a single byte of data into memory.

20. A method of generating an executable program, comprising:

generating an executable image from a source program, a portion of the source program requiring performance of at least one function; and

generating a plurality of code sequences, each code sequence performing a common selected function, each code sequence being better suited for execution in a corresponding one of different run-time environments than are the other code sequences, the code sequences being generated in a manner enabling execution, when the selected function is required to be performed by the executable image, of the better-suited code sequence in each of the run-time environments.