Method and system for modifying executable code to add additional functionality

• US 20030212983A1
• Filed: 02/18/2003
• Published: 11/13/2003
• Est. Priority Date: 12/14/1998
• Status: Active Grant

• Current Assignee: Apple Inc.
• Original Assignee: Freescale Semiconductor, Inc. (NXP Semiconductors NV)
• Inventors: Tinker, Jeffrey L.
• Granted Patent: US 6,948,164 B2
• Time in Patent Office: Days
• US Class Current: 717/110
• CPC Class Codes: G06F 8/65 Updates security arrangements therefor G06F21/57

Abstract

A system for modifying a compiled executable code file by adding patches that add functionality when the modified executable code file is executed. The modifying is performed without recompiling, relinking or rewriting the code file. Adding a patch involves creating a patch handler which when executed causes the patch statements to be executed, and may involve replacing one or more existing compiled instructions in the file with patching instructions to transfer flow of execution to the appropriate patch handler. The instructions replaced by the patching instructions can also be added to the patch handler. Patches can also include code statements which form a complete module, such as an invokable routine, which can be referenced by other patch statements to cause the module to be executed. Specialized trace requests can also be added as patch statements. The trace requests will make specified information about the current execution of the executable code file available to a software developer. Patch statements can include variables and expressions that will be evaluated in the context of the appropriate current variable scope, regardless of whether the scope is defined within the patch or by existing compiled instructions. After patches have been added, they can be disabled so as to prevent their execution without removing the patching instructions from the compiled executable file. Patches can also be qualified with conditions such that the patch will be executed only when the conditions are true at the time of execution.

Claims

1. A method for modifying an executable file including a plurality of compiled instructions, the compiled instructions natively executable on a target computer but not on a source computer, the modifying performed under control of the source computer without recompiling or relinking or rewriting the executable file, the method comprising:

under control of the source computer,

(a) loading the executable file onto the target computer;

(b) receiving a plurality of indications to modify the loaded executable file, each indication specifying one of the compiled instructions in the loaded executable file and at least one non-compiled executable instruction to be added to the loaded executable file;

(c) modifying the loaded executable file by, for each indication,

creating an instruction group including the specified at least one non-compiled executable instruction;

converting the instruction group into an executable non-compiled format not specific to the target computer; and

replacing the specified compiled instruction in the loaded executable file with an executable patch instruction associated with the converted instruction group, the patch instruction when executed to transfer flow of execution to the converted instruction group with which the patch instruction is associated; and

(d) loading the converted instruction groups into at least one memory area on the target computer, the at least one memory area distinct from a memory area on the target computer containing the loaded executable file; and

under control of the target computer, executing the modified loaded executable file by, as the flow of execution sequentially reaches each executable instruction,

(e) when the executable instruction is a non-compiled executable instruction from an instruction group, interpretively evaluating the executable instruction;

(f) when the executable instruction is a patch instruction, transferring flow of execution to the loaded associated converted instruction group; and

(g) when the executable instruction is a compiled instruction, natively executing the compiled executable instruction, so that additional functionality is exhibited when the modified loaded executable file is executed on the target computer.

2. The method of claim 1 wherein at least one of the non-compiled executable instructions is a trace instruction specifying information related to execution of the loaded executable file, and wherein when the flow of execution reaches the trace instruction a current state of the specified information is made available to the source computer.

3. The method of claim 2 wherein at least one of the instruction groups includes the specified compiled instruction that was replaced with the patch instruction associated with that instruction group.

4. The method of claim 1 wherein when multiple indications specify a single compiled instruction a single instruction group is created for the multiple indications, the single instruction group including the non-compiled executable instructions specified by each of the multiple indications.

5. The method of claim 1 wherein the patch instructions are transfer statements.

6. The method of claim 1 wherein the executable non-compiled format is a parse tree.

7. The method of claim 1 wherein when a non-compiled executable instruction is interpretively evaluated, references to variables are resolved using a current variable scope created by compiled instructions.

8. The method of claim 1 wherein after performing steps (a)-(g) a first time, steps (b)-(g) are performed a second time without performing step (a) a second time such that the modified loaded executable file is further modified and then executed without reloading the executable file.

9. A method for modifying a compiled file loaded on a target computer, the loaded compiled file including a plurality of instructions executable on the target computer, the method comprising:

modifying the loaded compiled file by,

under control of a source computer,

receiving an indication to modify the loaded compiled file by adding at least one instruction to be executed upon execution of the loaded compiled file;

creating a patch group including a plurality of instructions, the plurality of instructions including the indicated at least one instruction; and

replacing an instruction in the loaded compiled file with a patch instruction; and

loading the patch group into a first portion of memory on the target computer distinct from a second portion of memory on the target computer containing the loaded compiled file; and

on the target computer, executing the instructions in the modified loaded compiled file by, when an instruction to be executed is the patch instruction, indicating one of the plurality of instructions in the loaded patch group as a next instruction to be executed.

10. The method of claim 9 wherein the indicating of the one of the plurality of instructions involves transferring flow of execution to a first instruction in the loaded patch group.

11. The method of claim 10 wherein the plurality of instructions in the compiled file are in a compiled format specific to the target computer, wherein the plurality of instructions in the loaded patch group are in a non-compiled format not specific to the target computer, and wherein when an instruction to be executed is one of the plurality of instructions in the loaded patch group, the instruction is executed by interpreting the instruction.

12. The method of claim 11 wherein the non-compiled format is a parse tree.

13. The method of claim 10 wherein the patch group includes a return instruction that when executed transfers flow of execution back to an instruction in the loaded modified compiled file.

14. The method of claim 10 wherein the patch instruction is a transfer statement.

15. The method of claim 9 wherein the created patch group includes the replaced instruction.

16. The method of claim 9 wherein the indicated at least one instruction specifies that information related to execution of the loaded compiled file be provided for a user.

17. The method of claim 16 wherein when flow of execution reaches the indicated at least one instruction a current state of the specified information is determined using a current variable scope.

18. The method of claim 9 wherein the executing of the instructions in the modified loaded compiled file on the target computer is performed under interactive control of the source computer.

19. The method of claim 9 including before the modifying of the loaded compiled file, loading the compiled file into the second portion of memory.

20. The method of claim 19 including after the modifying of the loaded compiled file and the executing of the instructions in the modified loaded compiled file, performing the modifying and the executing again without performing the loading of the compiled file into memory again.

21. The method of claim 9 including:

halting the executing of the instructions in the modified loaded compiled file before the executing has completed;

performing the modifying of the loaded compiled file again; and

continuing the halted executing without restarting execution of the modified loaded compiled file.

22. A computer-implemented method for adding instructions to be executed to an executable compiled file without recompiling or rewriting the file, the method comprising:

receiving an indication to modify the compiled file, the indication specifying a compiled instruction in the compiled file and at least one executable instruction to be added;

modifying the compiled file by,

creating a patch group including the specified at least one executable instruction; and

replacing the specified compiled instruction in the compiled file with a patch instruction such that flow of execution will transfer to the created patch group upon execution of the patch instruction; and

storing separate from the patch group the modified compiled file including the patch instruction, so that instructions in the patch group will be executed when the modified compiled file is later executed.

23. The method of claim 22 wherein the instructions in the patch group are in a non-compiled format such that execution of the instructions involves interpreted evaluation.

24. The method of claim 22 wherein the created patch group includes a return instruction that when executed transfers flow of execution back to an instruction in the modified compiled file.

25. The method of claim 22 wherein the created patch group includes the replaced instruction.

26. The method of claim 22 wherein the specified at least one executable instruction will when executed provide trace information about current execution of the modified file.

27. The method of claim 26 wherein the trace information indicates when the specified compiled instruction is executed.

28. The method of claim 26 wherein the trace information indicates when a function including the specified compiled instruction is invoked.

29. The method of claim 22 wherein a plurality of executable instructions to be added are specified and wherein the created patch group includes a function with multiple instructions, the function invokable by other instructions.

30. The method of claim 22 wherein the modified compiled file is executed on a separate computer, and including:

supplying to the separate computer at least one direction related to the execution of the modified compiled file; and

displaying received results of performance of the supplied direction.

31. The method of claim 22 wherein without removing the patch instruction from the modified compiled file, the patch group is disabled such that the instructions in the patch group are not executed when the modified compiled file is executed.

32. A computer-implemented method for executing a modified compiled file including a plurality of original compiled instructions and at least one patch instruction in place of an original compiled instruction, each patch instruction when executed to transfer flow of execution to an associated patch group including a plurality of instructions, the method comprising:

loading the modified compiled file and the associated patch groups into memory; and

executing the modified compiled file by, as the flow of execution reaches each executable instruction,

when the executable instruction is an original compiled instruction, natively executing the executable instruction;

when the executable instruction is one of the patch instructions, transferring flow of execution to the associated patch group for the patch instruction; and

when the executable instruction is one of the plurality of instructions from a patch group, interpretively evaluating the executable instruction.

33. The method of claim 32 wherein the modified compiled file is loaded into memory on a target computer and wherein the plurality of instructions in the loaded patch groups are in a non-compiled format not specific to the target computer.

34. The method of claim 33 wherein the patch groups are loaded into memory on a source computer distinct from the target computer.

35. The method of claim 32 wherein a location in memory is determined for each patch group when the patch group is to be loaded, wherein the memory location of each loaded patch group is tracked, and wherein when a patch instruction is to be executed, the tracked current memory location of the associated patch group is determined to enable the transferring of the flow of execution.

36. The method of claim 32 wherein before each patch group is loaded into memory, a memory location is predetermined for the patch group and the patch instruction for the patch group indicates the predetermined memory location, the predetermined memory location to be used for the transferring of the flow of execution.

37. The method of claim 32 wherein the plurality of instructions in the loaded patch groups are specified in a non-compiled format.

38. The method of claim 32 wherein when interpretively evaluating instructions from a patch group, variables are evaluated in the context of current variable scopes.

39. The method of claim 32 wherein the executing of the modified compiled file is performed under interactive control of a distinct computer.

40. A computer system for adding instructions to be executed to an executable compiled file without recompiling or rewriting the file, comprising:

a command subsystem for receiving indications to modify the compiled file, each indication specifying a compiled instruction in the compiled file and at least one executable instruction to be added; and

a patching subsystem for modifying the compiled file by creating for each received indication an associated patch group including the specified at least one executable instruction, and by replacing the specified compiled instruction in the compiled file with a patch instruction such that flow of execution will transfer to the associated patch group upon execution of the patch instruction.

41. The computer system of claim 40 including a code fragment executables subsystem for converting instructions in the patch group into a non-compiled format such that execution of the instructions involves interpreted evaluation.

42. The computer system of claim 40 wherein the modified compiled file is executed on a separate computer, and wherein the command subsystem is further for receiving an indication to supply to the separate computer at least one direction related to the execution of the modified compiled file and for displaying received results of performance of the supplied direction.

43. The computer system of claim 40 wherein the specified at least one executable instruction will when executed provide trace information about current execution of the modified file.

44. The computer system of claim 40 including a patch interpreter subsystem for executing the modified compiled file by, as the flow of execution reaches each executable instruction,

when the executable instruction is a compiled instruction, natively executing the executable instruction;

when the executable instruction is one of the patch instructions, transferring flow of execution to the associated patch group for the patch instruction; and

when the executable instruction is one of the instructions from a patch group, interpretively evaluating the executable instruction.

45. A computer-readable medium containing instructions for controlling a computer system to add instructions to be executed to an executable compiled file without recompiling the file, by:

receiving an indication to modify the compiled file, the indication specifying a compiled instruction in the compiled file and at least one executable instruction to be added; and

modifying the compiled file by,

creating a patch group including the specified at least one executable instruction; and

replacing the specified compiled instruction in the compiled file with a patch instruction such that flow of execution will transfer to the created patch group upon execution of the patch instruction.

46. The computer-readable medium of claim 45 wherein the instructions in the patch group are in a non-compiled format such that execution of the instructions involves interpreted evaluation.

47. The computer-readable medium of claim 45 wherein the modified compiled file is executed on a computer separate from the controlled computer system, and wherein the controlled computer system is further controlled by:

supplying to the separate computer at least one direction related to the execution of the modified compiled file; and

displaying received results of performance of the supplied direction.

48. The computer-readable medium of claim 45 wherein the specified at least one executable instruction will when executed provide trace information about current execution of the modified file.

49. The computer-readable medium of claim 45 wherein the computer system is further controlled to execute the modified compiled file by, as the flow of execution reaches each executable instruction,

when the executable instruction is a compiled instruction, natively executing the executable instruction;

when the executable instruction is one of the patch instructions, transferring flow of execution to the associated patch group for the patch instruction; and

when the executable instruction is one of the instructions from a patch group, interpretively evaluating the executable instruction.

50. The computer-readable medium of claim 45 wherein the computer system is further controlled by, before the modifying of the compiled file, loading the compiled file into memory of a second computer system, and wherein the modifying of the compiled file modifies the loaded compiled file such that the specified compiled instruction is replaced in the loaded compiled file.

51. The computer-readable medium of claim 45 wherein the computer system is further controlled by, after the modifying of the compiled file executing on a target computer the modified compiled file by, when an instruction to be executed is the patch instruction, indicating an instruction in the created patch group as a next instruction to be executed.

52. The computer-readable medium of claim 51 wherein the computer system is further controlled by, after the executing of the modified compiled file, performing the modifying and the executing again without reloading the compiled file into memory.