Method and apparatus for the inter-operation of differing architectural and run time conventions

• US 6,199,202 B1
• Filed: 01/06/1998
• Issued: 03/06/2001
• Est. Priority Date: 01/06/1998
• Status: Expired due to Term

• Current Assignee: Hewlett Packard Enterprise Development LP (Hewlett-Packard Enterprise Company)
• Original Assignee: Hewlett-Packard Company (HP Inc.)
• Inventors: Istvan, Anthony F., Coutant, Cary, Buzbee, William B.
• Primary Examiner(s): Hafiz, Tariq R.
• Assistant Examiner(s): ZHEN, WEI Y
• Application Number:
  US09/003,573
• Time in Patent Office: 1,155 Days
• Field of Search: 395/710, 717/10, 717/5
• US Class Current: 717/138
• CPC Class Codes: G06F 9/44521 Dynamic linking or loading; Link editing at or after load time, e.g. Java class loading
• CPC Class Codes: G06F 9/45504 Abstract machines for programme code execution, e.g. Java virtual machine [JVM], interpreters, emulators

Abstract

The inventive mechanism allows an application to switch modes during its operation, between a compatibility or legacy mode for a previous architecture, and a native mode for a current architecture. The mechanism includes an official function descriptor which describes information for accessing a function which resides in one module. The OFD has a legacy portion is useable by a legacy module and a native portion is useable by a native module. The mechanism also includes a linkage table that resides in a second module which references the function in the first module. The portion of the OFD which corresponds to the mode of the linkage table module is copied into the linkage table. Each portion contains one entry that corresponds to an address location of the function, and another entry that is a value for a register which refers to the data segment corresponding to the load module containing the function. The information in the OFD depends on whether the function is a legacy function or a native function.

Claims

1. A method for operating an application in a current host system including at least one legacy module compiled for a legacy architecture, and at least one native module compiled for an architecture native to said current host system, the method comprising the steps of:

providing a first function descriptor which describes information for accessing a function which resides in a first module, and includes a legacy portion which would be useable by the at least one legacy module and a native portion which would be useable by the at least one native module wherein said at least one legacy module and said at least one native module execute within said current host system; and

copying, by a second module which references the function, one of the legacy portion and the native portion depending for which architecture the second module is compiled, into a linkage table residing in the second module.

2. The method of claim 1, wherein:

each portion of both the legacy portion and the native portion have two entries, with one entry corresponding to an address location of the function, and the other entry comprising a value for a register which refers to data corresponding to the first module which contains the function.

3. The method of claim 2, wherein:

each entry of the legacy portion is a 32 bit word; and

each entry of the native portion is a 64 bit word.

4. The method of claim 3, wherein the step of providing comprises the steps of:

offsetting the one entry of the legacy portion to zero bytes;

offsetting the other entry of the legacy portion to four bytes;

offsetting the one entry of the native portion to eight bytes; and

offsetting the other entry of the native portion to sixteen bytes.

5. The method of claim 2, wherein:

each entry of the legacy portion is a 64 bit word; and

each entry of the native portion is a 64 bit word.

6. The method of claim 5, wherein the step of providing comprises the steps of:

offsetting the one entry of the legacy portion to zero bytes;

offsetting the other entry of the legacy portion to eight bytes;

offsetting the one entry of the native portion to sixteen bytes; and

offsetting the other entry of the native portion to twenty four bytes.

7. The method of claim 2, wherein the step of providing comprises the steps of:

offsetting the one entry of the legacy portion by a first member of bytes;

offsetting the other entry of the legacy portion by a second number of bytes;

offsetting the one entry of the native portion by a third number of bytes; and

offsetting the other entry of the native portion by a fourth number of four bytes.

8. The method of claim 1, further comprising the step of:

linking, dynamically, the first and second modules to the application.

9. The method of claim 1, wherein the first and second modules are both legacy modules, and the step of copying comprises the steps of:

copying a first entry of the legacy portion into the linkage table, wherein the first entry is a legacy mode address to the function; and

copying a second entry of the legacy portion into the linkage table, wherein the second entry is a register value pointer to data.

10. The method of claim 9, further comprising the steps of:

branching to the address of the function; and

executing the function via emulation.

11. The method of claim 1, wherein the first and second modules are both native modules, and the step of copying comprises the steps of:

copying a first entry of the native portion into the linkage table, wherein the first entry is a native mode address to the function; and

copying a second entry of the native portion into the linkage table, wherein the second entry is a register value pointer to data.

12. The method of claim 11, further comprising the steps of:

branching to the address of the function; and

executing the function.

13. The method of claim 1, wherein the first module is a native module and the second module is a legacy module, and the step of copying comprises the steps of:

copying a first entry of the legacy portion into the linkage table, wherein the first entry is a native mode address to the function; and

copying a second entry of the legacy portion into the linkage table, wherein the second entry is a register value pointer to data.

14. The method of claim 13, further comprising the steps of:

registering the native mode address in a cache;

emulating the first module;

invoking the function;

consulting the cache to determine if the function is registered;

invoking a mode switch mechanism, if the function is registered, to switch application operation from legacy mode to native mode;

branching to the address of the function; and

executing the function.

15. The method of claim 1, wherein the first module is a legacy module and the second module is a native module, and the step of copying comprises the steps of:

copying a first entry of the native portion into the linkage table, wherein the first entry is a value which invokes a mode switch mechanism to switch application operation from native mode to legacy mode; and

copying a second entry of the native portion into the linkage table, wherein the second entry comprises two sub-entries, a first sub-entry is a legacy mode address to the function, and a second sub-entry is a register value pointer to data.

16. The method of claim 15, further comprising the steps of:

executing the first module;

invoking the function;

invoking the mode switch mechanism;

branching to an emulator;

extracting the first sub-entry and the second sub-entry, and emulating the function at the address of the first sub-entry.

17. A system for operating an application in a current host system including at least one legacy module compiled for a legacy architecture, and at least one native module compiled for an architecture native to said current host system the system comprising:

a first function descriptor which describes information for accessing a function which resides in a first module, and includes a legacy portion which would be useable by the at least one legacy module and a native portion which would be useable by the at least one native module, wherein said at least one legacy module and said at least one native module execute within said current host system; and

a linkage table residing in a second module which references the function, into which is copied one of the legacy portion and the native portion depending for which architecture the second module is compiled.

18. The system of claim 17, wherein:

each portion of both the legacy portion and the native portion have two entries, with one entry corresponding to an address location of the function, and the other entry comprising a value for a register which refers to data corresponding to the first module which contains the function.

19. The system of claim 18, wherein:

each entry of the legacy portion is a 32 bit word; and

each entry of the native portion is a 64 bit word.

20. The system of claim 19, wherein:

the one entry of the legacy portion is offset to zero bytes;

the other entry of the legacy portion is offset to four bytes;

the one entry of the native portion is offset to eight bytes; and

the other entry of the native portion is offset to sixteen bytes.

21. The system of claim 18, wherein:

each entry of the legacy portion is a 64 bit word; and

each entry of the native portion is a 64 bit word.

22. The system of claim 21, wherein:

the one entry of the legacy portion is offset to zero bytes;

the other entry of the legacy portion is offset to eight bytes;

the one entry of the native portion is offset to sixteen bytes; and

the other entry of the native portion is offset to twenty four bytes.

23. The system of claim 18, wherein:

the one entry of the legacy portion is offset by a first number of bytes;

the other entry of the legacy portion is offset by a second number of bytes;

the one entry of the native portion is offset by a third number of bytes; and

the other entry of the native portion is offset by a fourth number of bytes.

24. The system of claim 17, further comprising:

means for dynamically linking the first and second modules to the application.

25. The system of claim 17, wherein the first and second modules are both legacy modules, and the system further comprises:

means for copying a first entry of the legacy portion into the linkage table, wherein the first entry is a legacy mode address to the function; and

means for copying a second entry of the legacy portion into the linkage table, wherein the second entry is a register value pointer to data.

26. The system of claim 25, further comprising:

means for branching to the address of the function; and

means for executing the function via emulation.

27. The system of claim 17, wherein the first and second modules are both native modules, and the system further comprises:

means for copying a first entry of the native portion into the linkage table, wherein the first entry is a native mode address to the function; and

means for copying a second entry of the native portion into the linkage table, wherein the second entry is a register value pointer to data.

28. The system of claim 27, further comprising:

means for branching to the address of the function; and

means for executing the function.

29. The system of claim 17, wherein the first module is a native module and the second module is a legacy module, and the system further comprises:

means for copying a first entry of the legacy portion into the linkage table, wherein the first entry is a native mode address to the function; and

means for copying a second entry of the legacy portion into the linkage table, wherein the second entry is a register value pointer to data.

30. The system of claim 29, further comprising:

means for registering the native mode address in a cache;

means for emulating the first module;

means for invoking the function;

means for consulting the cache to determine if the function is registered;

means for invoking a mode switch mechanism, if the function is registered, to switch application operation from legacy mode to native mode;

means for branching to the address of the function; and

means for executing the function.

31. The system of claim 17, wherein the first module is a legacy module and the second module is a native module, and the system further comprises:

means for copying a first entry of the native portion into the linkage table, wherein the first entry is a value which invokes a mode switch mechanism to switch application operation from native mode to legacy mode; and

means for copying a second entry of the native portion into the linkage table, wherein the second entry comprises two sub-entries, a first sub-entry is a legacy mode address to the function, and a second sub-entry is a register value pointer to data.

32. The system of claim 31, further comprising:

means for executing the first module;

means for invoking the function;

means for invoking the mode switch mechanism;

means for branching to an emulator;

means for extracting the first sub-entry and the second sub-entry; and

means for emulating the function at the address of the first sub-entry.

33. A computer program product having a computer readable medium having computer program logic recorded thereon for operating an application in a current host system including at least one legacy module compiled for a legacy architecture, and at least one native module compiled for an architecture native to said current host system, the computer program product comprising:

code for providing a first function descriptor which describes information for accessing a function which resides in a first module, and includes a legacy portion which would be useable by the at least one legacy module and a native portion which would be useable by the at least one native module, wherein said at least one legacy module and said at least one native module execute within said current host system; and

code for copying, by a second module which references the function, one of the legacy portion and the native portion depending for which architecture the second module is compiled, into a linkage table residing in the second module.

34. The computer program product of claim 33, wherein:

each portion of both the legacy portion and the native portion have two entries, with one entry corresponding to an address location of the function, and the other entry comprising a value for a register which refers to data corresponding to the first module which contains the function.

35. The computer program product of claim 34, wherein:

each entry of the legacy portion is a 32 bit word; and

each entry of the native portion is a 64 bit word.

36. The computer program product of claim 35, wherein the code for providing comprises:

code for offsetting the one entry of the legacy portion to zero bytes;

code for offsetting the other entry of the legacy portion to four bytes;

code for offsetting the one entry of the native portion to eight bytes; and

code for offsetting the other entry of the native portion to sixteen bytes.

37. The computer program product of claim 34, wherein:

each entry of the legacy portion is a 64 bit word; and

each entry of the native portion is a 64 bit word.

38. The computer program product of claim 37, wherein the code for providing comprises:

code for offsetting the one entry of the legacy portion to zero bytes;

code for offsetting the other entry of the legacy portion to eight bytes;

code for offsetting the one entry of the native portion to sixteen bytes; and

code for offsetting the other entry of the native portion to twenty four bytes.

39. The computer program product of claim 34, wherein the code for providing comprises:

code for offsetting the one entry of the legacy portion by a first number of bytes;

code for offsetting the other entry of the legacy portion by a second number of bytes;

code for offsetting the one entry of the native portion by a third number of bytes; and

code for offsetting the other entry of the native portion by a fourth number of four bytes.

40. The computer program product of claim 33, further comprising:

code for linking, dynamically, the first and second modules to the application.

41. The computer program product of claim 33, wherein the first and second modules are both legacy modules, and the step of copying comprises the steps of:

copying a first entry of the legacy portion into the linkage table, wherein the first entry is a legacy mode address to the function; and

copying a second entry of the legacy portion into the linkage table, wherein the second entry is a register value pointer to data.

42. The computer program product of claim 41, further comprising:

code for branching to the address of the function; and

code for executing the function via emulation.

43. The computer program product of claim 33, wherein the first and second modules are both native modules, and the code for copying comprises:

code for copying a first entry of the native portion into the linkage table, wherein the first entry is a native mode address to the function; and

code for copying a second entry of the native portion into the linkage table, wherein the second entry is a register value pointer to data.

44. The computer program product of claim 43, further comprising:

code for branching to the address of the function; and

code for executing the function.

45. The computer program product of claim 33, wherein the first module is a native module and the second module is a legacy module, and the code for copying comprises:

code for copying a first entry of the legacy portion into the linkage table, wherein the first entry is a native mode address to the function; and

code for copying a second entry of the legacy portion into the linkage table, wherein the second entry is a register value pointer to data.

46. The computer program product of claim 45, further comprising:

code for registering the native mode address in a cache;

code for emulating the first module;

code for invoking the function;

code for consulting the cache to determine if the function is registered;

code for invoking a mode switch mechanism, if the function is registered, to switch application operation from legacy mode to native mode;

code for branching to the address of the function; and

code for executing the function.

47. The computer program product of claim 33, wherein the first module is a legacy module and the second module is a native module, and the code for copying comprises:

code for copying a first entry of the native portion into the linkage table, wherein the first entry is a value which invokes a mode switch mechanism to switch application operation from native mode to legacy mode; and

code for copying a second entry of the native portion into the linkage table, wherein the second entry comprises two sub-entries, a first sub-entry is a legacy mode address to the function, and a second sub-entry is a register value pointer to data.

48. The computer program product of claim 47, further comprising:

code for executing the first module;

code for invoking the function;

code for invoking the mode switch mechanism;

code for branching to an emulator;

code for extracting the first sub-entry and the second sub-entry; and

code for emulating the function at the address of the first sub-entry.

49. A system for operating an application in a current host system including at least one legacy module compiled for a legacy architecture, and at least one native module compiled for an architecture native to said current host system, the system comprising:

a first function descriptor which describes information for accessing a function which resides in a first module, and includes a legacy portion which would be useable by the at least one legacy module and a native portion which would be useable by the at least one native module;

a linkage table residing in a second module which references the function, into which is copied one of the legacy portion and the native portion depending upon which architecture the second module is compiled for, into a linkage table residing in the second module; and

an emulator for emulating code in said at least one legacy module.