Patent US2708322A successfully refreshed from Google Patents.
EP1014263A2
Expired / Lapsed
EP
⏱️ 0.0 years remaining
Method and system for modifying executable code to add additional functionality
Assignee: NXP USA Inc
•
Filing: 1999-12-13
•
Granted: —
•
Expires: 2019-12-13
Abstract
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.
Inventors
- 👤 Jeffrey L. Tinker
Bibliographic Details
Application Number
—
Jurisdiction
EP
Data Source
google_patents
Last Synchronized
2026-11-06 14:28
CPC Classifications
G; G06; G06F; G06F8/00; G06F8/60; G06F8/65
Claims Analysis
Total Claims: 10
Claim 1
Independent Claim
320 words
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.
Claim 2
Dependent Claim
45 words
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.
Claim 3
Dependent Claim
132 words
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.
Claim 4
Dependent Claim
46 words
The method of claim 3 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.
Claim 5
Dependent Claim
39 words
The method of claim 3 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.
Claim 6
Dependent Claim
138 words
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.
Claim 7
Dependent Claim
111 words
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.
Claim 8
Dependent Claim
103 words
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.
Claim 9
Dependent Claim
56 words
The computer-readable medium of claim 8 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.
Claim 10
Dependent Claim
36 words
The computer-readable medium of claim 9 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.
References Cited (Backward Citations)
No citation records indexed.
USPTO Annuity & Maintenance Windows
Maintenance schedule is calculated for granted US utility patents.