US20030014737A1 - Computer method and apparatus for safe instrumentation of reverse executable program modules - Google Patents
Computer method and apparatus for safe instrumentation of reverse executable program modules Download PDFInfo
- Publication number
- US20030014737A1 US20030014737A1 US10/237,449 US23744902A US2003014737A1 US 20030014737 A1 US20030014737 A1 US 20030014737A1 US 23744902 A US23744902 A US 23744902A US 2003014737 A1 US2003014737 A1 US 2003014737A1
- Authority
- US
- United States
- Prior art keywords
- prologue
- identified portion
- working copy
- program
- instructions
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Abandoned
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
Definitions
- a computer application i.e., program
- lines of code a series of instructions referred to as “lines of code”. Initially, these instructions are written in a human readable programming language, e.g., Fortran, C++, etc. This is referred to as the program source code.
- a compiler transforms the source code into machine readable code. It is the machine readable code, or a binary image of the same, that is the executable form (by a digital processor) of the application program.
- instrumentation points are desired to be inserted into the executable image.
- new procedure invocations are introduced into the program.
- Instrumented programs are executed in the same manner as the original program, with the new procedures being invoked at the instrumented points in the program.
- These new procedures, or analysis routines provide, for example, the values of parameters at the instrumentation point in the program, the number of times a procedure in the program is called, and other information about certain parts of the program.
- the new procedures/analysis routines of the instrumented program provide the capability for debugging and other types of analysis of the program.
- the instrumented application produces the desired type of analysis action as it runs.
- Instrumentation points are allowed at procedure boundaries, basic block boundaries and/or instruction boundaries. Introducing binary instrumentation into the prologue code (initialization portion) of a procedure is a difficult problem. The primary issue is that if prologue code is used as an exception-handling mechanism for unwinding the stack frame, the introduction of other instructions into the prologue may compromise or break exception handling.
- the present invention provides a method and apparatus to safely insert instrumentation code into the prologue of a procedure.
- the invention works with programming models that respond to exceptions or unwinding mechanisms by reverse executing the prologue code. Reverse execution of the prologue returns the state of the program to a condition that it was prior to the execution of the procedure.
- the invention method introduces binary instrumentation into a procedure's prologue by duplicating components of the prologue and then instrumenting the original version of the prologue.
- the non-standard prologue instructions are preserved in the original sequence of instrumented prologue instructions. The net effect is that exception handling is preserved and the full prologue with non-standard instructions can be instrumented and executed without altering the program's intended behavior.
- the method includes the steps of: (a) identifying a portion of the subject program into which insertion of instrumentation code is desired; (b) duplicating the identified portion such that a working copy of the identified portion is formed, said duplicating including placing the working copy before the identified portion; (c) removing instructions from the working copy such that only instructions necessary to restore calling context remains; (d) instrumenting the identified portion; and (e) enabling the working copy for use during reverse execution of the subject program and otherwise effecting use of the instrumented identified portion in the subject program.
- rewind instructions are inserted between the working copy and the original identified portions to reverse the effect of duplicated instructions in the identified portion.
- working constructs i.e., pointers
- the working copy serves as an entry point and the original identified portion is effectively part of the main body of a program module.
- Apparatus of the present invention includes an instrumentation assembly coupled to an instrumentation coder.
- the instrumentation assembly effects steps (a), (b), (c) and (e) of the foregoing method.
- the instrumentation coder effects step (d).
- the instrumentation coder follows techniques of U.S. Pat. Nos. 5,539,907 and 5,732,273.
- FIG. 1 is a block diagram of a computer processor assembly embodying the present invention.
- FIGS. 2 A- 2 B are schematic views illustrating instrumentation of a procedure prologue.
- FIG. 3 illustrates a prologue implemented according to the invention.
- FIG. 4 is a block diagram outlining the steps of the invention method.
- FIG. 1 Illustrated in FIG. 1 is a digital processor 11 holding the binary code of an application program 13 in working memory 15 .
- the binary code 13 comprises a plurality of modules. Each module is formed of several to thousands of lines of instructions. Shown is a procedure module 14 and a main body module 16 in which there is a call 19 to the procedure module 14 . During execution, one instruction after another in the main body 16 of the subject program 13 is processed. When the call instruction 19 is reached, the procedure module (indicated in the call instruction) is invoked.
- Invocation of the procedure module 14 involves initializing a stack frame 17 to store the calling context. That is, memory address of the calling instruction 19 is saved/ recorded on the stack frame 17 , as is the return address (i.e., memory location to which to continue processing after the called procedure module) and other information required to restore the procedure calling context. Lastly, initial values of the procedure module variables are assigned using parameters passed into the called procedure module 14 via the call instruction 19 . This sets the initial state of the procedure module 14 .
- the digital processor 11 then processes one instruction after the other in the procedure module 14 .
- the digital processor 11 reverse executes a current subject module one instruction at a time. This is referred to as “unwinding”.
- the stack frame is used in the exception handling of a procedure 14 to unwind to the point/state where the procedure module 14 was invoked and originally called. That is, the state data stored in the stack frame 17 is used to return variables to the state at which the procedure module 14 was invoked/called.
- the calling address is used to backtrack to the call instruction 19 in the main body 16 of the subject program 13 that called the procedure module 14 . Further unwinding of the procedure prologue associated with program body 16 may then be enabled.
- Instrumentation assembly 31 provides instrumentation of program 13 before and/or after (e.g., outside of) execution runs in working memory 15 as detailed later in FIG. 4.
- the procedure module 14 is formed of a prologue portion 21 and main procedure body portion 23 , as illustrated in FIG. 2A.
- the prologue portion 21 contains the instructions for initializing the stack frame with calling context information and state data.
- FIG. 2B shows that during instrumentation (outside of execution), it is desirable to insert into the procedure prologue 21 a series of instructions that adjust the stack frame, save information onto the stack, branch to an analysis routine and then restore the stack frame pointer to its former position.
- Such a branch instruction and associated analysis routine enable monitoring of state values, counting of the number of times the procedure module has been invoked, and other measuring of program operation.
- instrumentation of the prologue 21 is performed in a manner that preserves, in proper sequence, the instructions in the prologue needed for unwinding. This is accomplished as follows and illustrated in FIGS. 3 and 4.
- an API (application program interface) 27 provides an interactive user interface for instrumenting program 13 .
- instrumentation assembly 31 locates the binary code (step 41 in FIG. 4) for the designated prologue 21 and makes a copy (step 43 ) into scratch memory 33 .
- the instrumentation assembly 31 assesses each instruction for unwinding purposes. That is, if a subject instruction in the scratch memory copy is not necessary for the unwinding process, then at step 45 the instrumentation assembly 31 deletes that instruction from the scratch memory 33 copy of the prologue. As such, the instrumentation assembly 31 sanitizes the scratch memory copy of prologue 21 and only the instructions necessary for restoring the calling context during unwinding handling remain in the prologue copy at scratch memory 33 .
- the instrumentation assembly 31 For each instruction remaining in the resulting prologue copy (in scratch memory 33 ), the instrumentation assembly 31 generates a corresponding rewind or reverse effect of that instruction (step 47 ), if required.
- the generated rewind instructions are appended to the prologue copy in scratch memory 33 .
- the final contents of the scratch memory 33 are inserted before the original prologue 21 in the subject program binary code 13 in working memory 15 (FIG. 1).
- step 49 the instrumentation assembly 31 redefines beginning and ending boundaries of the original prologue 21 to be set to (i.e., point to) the copy of the prologue that came from scratch memory 33 .
- the new rewind instructions from step 47 are seen as part of the main body 23 of the procedure 14 along with the original prologue instructions.
- FIG. 3 illustrates prologue 21 instrumented according to the present invention.
- the duplicate and sanitized version of the prologue is at 37 , i.e., instructions at DPINS ( 1 ) . . . DPINS (n).
- the beginning point or entry point to the now instrumented procedure module 14 a is at 29 and an ending point prologue and procedure main body is set at 39 .
- the rewind instructions from step 47 (FIG. 4) are at 35 and indicated as RWINS ( 1 ) . . . RWINS (n).
- the original prologue instructions (OPINS ( 1 ) . . . OPINS (n)) with desired instrumentation instructions (IINS( 1 ) . . . IINS(n)) inserted are at 21 a in FIG. 3.
- the original procedure 14 is at 23 .
- the combination of code at 21 a , 35 and 23 is as the body of main procedure body for instrumented procedure 14 a.
- the processor 11 effectively executes the prologue instructions twice, the first time at 37 without instrumentation and the second time at 21 a with instrumentation.
- the duplicate prologue instructions 37 are seen as the official prologue of the instrumented procedure 14 a from the viewpoint of the procedure descriptor and the unwinding mechanism.
- the original prologue instructions at 21 a are considered part of the procedure body along with the original procedure body 23 .
- the processor 11 processes DPINS instructions 37 one at a time as the prologue of the invoked procedure 14 a .
- the processor 11 processes the main body of the procedure 14 a starting with the RWINS instructions 35 .
- the exception-handling rewinding begins at the set ending boundary 39 of what is seen as the official prologue 37 but is the duplicate or prologue copy from scratch memory 33 (FIG. 1).
- this version of the prologue 37 does not contain any instrumentation code and fully preserves the calling context, the unwinding mechanism succeeds in reverse executing the then apparent prologue 37 .
- the present invention enables the instrumentation of prologue code in a manner such that in cases where an exception occurs which causes the unwinding of the calling context to occur, the call chain is maintained.
- prologue instructions may be copied directly into the subject binary program.
- rewind instructions may be inserted directly into the binary program instead of appended in scratch memory.
Abstract
Computer method and apparatus allows instrumentation of program modules while maintaining exception-handling unwinding context. In the case of instrumenting procedure prologues, the invention preserves the calling context. A sanitized copy of the prologue and rewind instructions to reverse the effects of duplicate prologue instructions are employed.
Description
- This application is a continuation of U.S. application Ser. No. 09/410,388, filed Sep. 30, 1999, the entire teachings of which are incorporated herein by reference.
- A computer application (i.e., program) is formed of a series of instructions referred to as “lines of code”. Initially, these instructions are written in a human readable programming language, e.g., Fortran, C++, etc. This is referred to as the program source code. A compiler transforms the source code into machine readable code. It is the machine readable code, or a binary image of the same, that is the executable form (by a digital processor) of the application program.
- To assist in debugging or analyzing a program, certain additional machine readable lines of code called instrumentation points are desired to be inserted into the executable image. At these specified points, new procedure invocations are introduced into the program. Instrumented programs are executed in the same manner as the original program, with the new procedures being invoked at the instrumented points in the program. These new procedures, or analysis routines, provide, for example, the values of parameters at the instrumentation point in the program, the number of times a procedure in the program is called, and other information about certain parts of the program. To that end, the new procedures/analysis routines of the instrumented program provide the capability for debugging and other types of analysis of the program. When executed, the instrumented application produces the desired type of analysis action as it runs.
- Instrumentation points are allowed at procedure boundaries, basic block boundaries and/or instruction boundaries. Introducing binary instrumentation into the prologue code (initialization portion) of a procedure is a difficult problem. The primary issue is that if prologue code is used as an exception-handling mechanism for unwinding the stack frame, the introduction of other instructions into the prologue may compromise or break exception handling.
- In the Atom and NT-Atom (both by Digital Equipment Corporation of Maynard, Massachusetts) instrumentation frameworks, the ability to properly instrument the prologue is a fundamental requirement for doing simulated performance studies. The current method that Atom utilizes on Tru64 Unix is to insert instrumentation code directly in the prologue potentially breaking exception handling of instrumented Tru64 applications. The current released version of NT-Atom does not instrument the prologue of any routine, thus guaranteeing that exception handling will operate properly.
- Thus there is need for a technique which allows binary instrumentation of prologue code in program procedures while preserving the exception-handling's mechanism for unwinding the procedures stack frame. Such is the object of the present invention.
- The present invention provides a method and apparatus to safely insert instrumentation code into the prologue of a procedure. The invention works with programming models that respond to exceptions or unwinding mechanisms by reverse executing the prologue code. Reverse execution of the prologue returns the state of the program to a condition that it was prior to the execution of the procedure.
- The invention method introduces binary instrumentation into a procedure's prologue by duplicating components of the prologue and then instrumenting the original version of the prologue. The non-standard prologue instructions are preserved in the original sequence of instrumented prologue instructions. The net effect is that exception handling is preserved and the full prologue with non-standard instructions can be instrumented and executed without altering the program's intended behavior.
- In the preferred embodiment, the method includes the steps of: (a) identifying a portion of the subject program into which insertion of instrumentation code is desired; (b) duplicating the identified portion such that a working copy of the identified portion is formed, said duplicating including placing the working copy before the identified portion; (c) removing instructions from the working copy such that only instructions necessary to restore calling context remains; (d) instrumenting the identified portion; and (e) enabling the working copy for use during reverse execution of the subject program and otherwise effecting use of the instrumented identified portion in the subject program.
- Further, rewind instructions are inserted between the working copy and the original identified portions to reverse the effect of duplicated instructions in the identified portion. Preferably, working constructs (i.e., pointers) are set such that the working copy serves as an entry point and the original identified portion is effectively part of the main body of a program module.
- Apparatus of the present invention includes an instrumentation assembly coupled to an instrumentation coder. The instrumentation assembly effects steps (a), (b), (c) and (e) of the foregoing method. The instrumentation coder effects step (d). Preferably, the instrumentation coder follows techniques of U.S. Pat. Nos. 5,539,907 and 5,732,273.
- The foregoing and other objects, features and advantages of the invention will be apparent from the following more particular description of preferred embodiments of the invention, as illustrated in the accompanying drawings in which like reference characters refer to the same parts throughout the different views. The drawings are not necessarily to scale, emphasis instead being placed upon illustrating the principles of the invention.
- FIG. 1 is a block diagram of a computer processor assembly embodying the present invention.
- FIGS.2A-2B are schematic views illustrating instrumentation of a procedure prologue.
- FIG. 3 illustrates a prologue implemented according to the invention.
- FIG. 4 is a block diagram outlining the steps of the invention method.
- Illustrated in FIG. 1 is a
digital processor 11 holding the binary code of anapplication program 13 inworking memory 15. Typically, thebinary code 13 comprises a plurality of modules. Each module is formed of several to thousands of lines of instructions. Shown is aprocedure module 14 and amain body module 16 in which there is acall 19 to theprocedure module 14. During execution, one instruction after another in themain body 16 of thesubject program 13 is processed. When thecall instruction 19 is reached, the procedure module (indicated in the call instruction) is invoked. - Invocation of the
procedure module 14 involves initializing astack frame 17 to store the calling context. That is, memory address of thecalling instruction 19 is saved/ recorded on thestack frame 17, as is the return address (i.e., memory location to which to continue processing after the called procedure module) and other information required to restore the procedure calling context. Lastly, initial values of the procedure module variables are assigned using parameters passed into the calledprocedure module 14 via thecall instruction 19. This sets the initial state of theprocedure module 14. - The
digital processor 11 then processes one instruction after the other in theprocedure module 14. - In the case of an exception that is not processed in the immediate context of the procedure, the
digital processor 11 reverse executes a current subject module one instruction at a time. This is referred to as “unwinding”. The stack frame is used in the exception handling of aprocedure 14 to unwind to the point/state where theprocedure module 14 was invoked and originally called. That is, the state data stored in thestack frame 17 is used to return variables to the state at which theprocedure module 14 was invoked/called. The calling address is used to backtrack to thecall instruction 19 in themain body 16 of thesubject program 13 that called theprocedure module 14. Further unwinding of the procedure prologue associated withprogram body 16 may then be enabled. - Being supported by
stack frames 17, pointers and similar stored memory address information, the backtracking or unwinding is fairly certain and stable. It is the altering of theprogram code 13 with additional adjustments to the stack frame pointer and other memory address changing instructions during instrumentation of the prior art that causes unwinding to fail. Thus, as previously mentioned, exception handling becomes problematic in instrumented programs of the prior art. - Referring back to FIG. 1, an
instrumentation assembly 31 of the present invention is also stored in processor memory.Instrumentation assembly 31 provides instrumentation ofprogram 13 before and/or after (e.g., outside of) execution runs in workingmemory 15 as detailed later in FIG. 4. - More specifically, the
procedure module 14 is formed of aprologue portion 21 and mainprocedure body portion 23, as illustrated in FIG. 2A. Theprologue portion 21 contains the instructions for initializing the stack frame with calling context information and state data. As shown in FIG. 2B, during instrumentation (outside of execution), it is desirable to insert into the procedure prologue 21 a series of instructions that adjust the stack frame, save information onto the stack, branch to an analysis routine and then restore the stack frame pointer to its former position. Such a branch instruction and associated analysis routine enable monitoring of state values, counting of the number of times the procedure module has been invoked, and other measuring of program operation. - When prior art instrumentation has inserted a branch (or other memory address changing)
instruction 25 in theprologue 21, the exception-handling unwinding process breaks down as follows. Invocation and initialization of theprocedure 14/prologue is as before.Processor 11 processes one instruction after another sequencing throughprologue 21. As shown in FIG. 2B, an “lda” instruction is processed, followed by a “stq” instruction, etc. If an exception is invoked in the body of the procedure that requires unwinding the procedure, then theprocessor 11 proceeds to unwind reverse execute and effectively undo each reversible instruction in theprologue 21. That is,processor 11 reverse executes each of thestore instructions processor 11 attempts to adjust the stack pointer at instruction i4. This and subsequent adjustments to the stack pointer (i1 and regular prologue instruction 1) result in an over adjustment of the stack that breaks the unwinding mechanism. - In the present invention, instrumentation of the
prologue 21 is performed in a manner that preserves, in proper sequence, the instructions in the prologue needed for unwinding. This is accomplished as follows and illustrated in FIGS. 3 and 4. Referring to FIGS. 1 and 4, an API (application program interface) 27 provides an interactive user interface for instrumentingprogram 13. In response to user request to insert instrumentation code into theprologue 21 ofprocedure module 14,instrumentation assembly 31 locates the binary code (step 41 in FIG. 4) for the designatedprologue 21 and makes a copy (step 43) intoscratch memory 33. - With the scratch memory copy, the
instrumentation assembly 31 assesses each instruction for unwinding purposes. That is, if a subject instruction in the scratch memory copy is not necessary for the unwinding process, then atstep 45 theinstrumentation assembly 31 deletes that instruction from thescratch memory 33 copy of the prologue. As such, theinstrumentation assembly 31 sanitizes the scratch memory copy ofprologue 21 and only the instructions necessary for restoring the calling context during unwinding handling remain in the prologue copy atscratch memory 33. - Next, for each instruction remaining in the resulting prologue copy (in scratch memory33), the
instrumentation assembly 31 generates a corresponding rewind or reverse effect of that instruction (step 47), if required. The generated rewind instructions are appended to the prologue copy inscratch memory 33. The final contents of thescratch memory 33 are inserted before theoriginal prologue 21 in the subjectprogram binary code 13 in working memory 15 (FIG. 1). - At
step 49 theinstrumentation assembly 31 redefines beginning and ending boundaries of theoriginal prologue 21 to be set to (i.e., point to) the copy of the prologue that came fromscratch memory 33. The new rewind instructions fromstep 47 are seen as part of themain body 23 of theprocedure 14 along with the original prologue instructions. - Instrumentation of the original prologue21 (step 51) is then enabled and effected in accordance with U.S. Pat. No's. 5,539,907 and 5,732,273, or the like.
- FIG. 3 illustrates
prologue 21 instrumented according to the present invention. The duplicate and sanitized version of the prologue is at 37, i.e., instructions at DPINS (1) . . . DPINS (n). The beginning point or entry point to the now instrumentedprocedure module 14 a is at 29 and an ending point prologue and procedure main body is set at 39. This effectively poses the DPINS(1) . . . (n) instructions at 37 as the prologue of instrumentedprocedure 14 a. The rewind instructions from step 47 (FIG. 4) are at 35 and indicated as RWINS (1) . . . RWINS (n). The original prologue instructions (OPINS (1) . . . OPINS (n)) with desired instrumentation instructions (IINS(1) . . . IINS(n)) inserted are at 21 a in FIG. 3. Theoriginal procedure 14 is at 23. The combination of code at 21 a, 35 and 23 is as the body of main procedure body for instrumentedprocedure 14 a. - That is, during execution, the
processor 11 effectively executes the prologue instructions twice, the first time at 37 without instrumentation and the second time at 21 a with instrumentation. Theduplicate prologue instructions 37 are seen as the official prologue of the instrumentedprocedure 14 a from the viewpoint of the procedure descriptor and the unwinding mechanism. The original prologue instructions at 21 a are considered part of the procedure body along with theoriginal procedure body 23. - With regard to execution and exception handling, the
processor 11 processes DPINSinstructions 37 one at a time as the prologue of the invokedprocedure 14 a. Next, theprocessor 11 processes the main body of theprocedure 14 a starting with theRWINS instructions 35. If an exception is invoked, the exception-handling rewinding begins at theset ending boundary 39 of what is seen as theofficial prologue 37 but is the duplicate or prologue copy from scratch memory 33 (FIG. 1). Where this version of theprologue 37 does not contain any instrumentation code and fully preserves the calling context, the unwinding mechanism succeeds in reverse executing the thenapparent prologue 37. - To that end, the present invention enables the instrumentation of prologue code in a manner such that in cases where an exception occurs which causes the unwinding of the calling context to occur, the call chain is maintained.
- While this invention has been particularly shown and described with references to preferred embodiments thereof, it will be understood by those skilled in the art that various changes in form and details may be made therein without departing from the scope of the invention encompassed by the appended claims.
- For example, instead of copying the prologue (or program module to be instrumented) into
scratch memory 33, prologue instructions may be copied directly into the subject binary program. Similarly, the rewind instructions may be inserted directly into the binary program instead of appended in scratch memory. - Further, the foregoing has discussed instrumentation of a procedure prologue. Other program modules may be similarly instrumented using the above-described techniques/steps of the present invention.
Claims (6)
1. A computer usable medium having computer readable code thereon, for inserting binary instrumentation code into a binary image of a subject program, the computer readable code when executed on a computer processor causing the processor to perform the steps of:
identifying a portion of the subject program into which insertion of instrumentation code is desired, the identified portion including an original prologue of a program procedure;
duplicating the identified portion such that a working copy of the identified portion is formed, said duplicating including placing the working copy before the identified portion;
removing instructions from the working copy such that only instructions necessary to restore calling context remains;
instrumenting the identified portion; and
enabling the working copy for use during exception handling of the subject program and otherwise effecting use of the instrumented identified portion in the subject program.
2. A computer usable medium as claimed in claim 1 further causing the processor to provide reverse instructions for reverse effecting the working copy of the identified portion.
3. A computer usable medium as claimed in claim 1 wherein the step of enabling the working copy includes setting constructs such that the working copy serves as a prologue and the original prologue is executed as part of a main body of the program procedure.
4. Computer apparatus for inserting binary instrumentation code into a binary image of a subject program comprising:
means for identifying a portion of the subject program into which insertion of instrumentation code is desired, the identified portion including an original prologue of a program procedure;
means for duplicating the identified portion such that a working copy of the identified portion is formed, said duplicating including placing the working copy before the identified portion;
means for removing instructions from the working copy such that only instructions necessary to restore calling context remains;
means for instrumenting the identified portion; and
means for enabling the working copy for use during exception handling of the subject program and otherwise effecting use of the instrumented identified portion in the subject program.
5. Computer apparatus as claimed in claim 4 further comprising means for providing reverse instructions for reverse effecting the working copy of the identified portion.
6. Computer apparatus as claimed in claim 4 wherein the means for enabling the working copy further sets constructs such that the working copy serves as a prologue and the original prologue is executed as part of a main body of the program procedure.
Priority Applications (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US10/237,449 US20030014737A1 (en) | 1999-09-30 | 2002-09-06 | Computer method and apparatus for safe instrumentation of reverse executable program modules |
Applications Claiming Priority (2)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US09/410,388 US6470493B1 (en) | 1999-09-30 | 1999-09-30 | Computer method and apparatus for safe instrumentation of reverse executable program modules |
US10/237,449 US20030014737A1 (en) | 1999-09-30 | 2002-09-06 | Computer method and apparatus for safe instrumentation of reverse executable program modules |
Related Parent Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US09/410,388 Continuation US6470493B1 (en) | 1999-09-30 | 1999-09-30 | Computer method and apparatus for safe instrumentation of reverse executable program modules |
Publications (1)
Publication Number | Publication Date |
---|---|
US20030014737A1 true US20030014737A1 (en) | 2003-01-16 |
Family
ID=23624510
Family Applications (2)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US09/410,388 Expired - Fee Related US6470493B1 (en) | 1999-09-30 | 1999-09-30 | Computer method and apparatus for safe instrumentation of reverse executable program modules |
US10/237,449 Abandoned US20030014737A1 (en) | 1999-09-30 | 2002-09-06 | Computer method and apparatus for safe instrumentation of reverse executable program modules |
Family Applications Before (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US09/410,388 Expired - Fee Related US6470493B1 (en) | 1999-09-30 | 1999-09-30 | Computer method and apparatus for safe instrumentation of reverse executable program modules |
Country Status (1)
Country | Link |
---|---|
US (2) | US6470493B1 (en) |
Cited By (7)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20030115561A1 (en) * | 2001-12-13 | 2003-06-19 | Robert Hundt | Lazy and precise update of unwind information for dynamically generated code |
US20070038975A1 (en) * | 2005-08-15 | 2007-02-15 | Sony Ericsson Mobile Communications Ab | Systems, methods and computer program products for safety checking executable application programs in a module |
US20080065872A1 (en) * | 2003-06-23 | 2008-03-13 | Ju Dz-Ching | Methods and apparatus for preserving precise exceptions in code reordering by using control speculation |
US20100275185A1 (en) * | 2009-04-24 | 2010-10-28 | Felix Burton | System and Method for High Performance Coverage Analysis |
US20110167248A1 (en) * | 2010-01-07 | 2011-07-07 | Microsoft Corporation | Efficient resumption of co-routines on a linear stack |
US20120144375A1 (en) * | 2010-12-02 | 2012-06-07 | International Business Machines Corporation | Reversibly instrumenting a computer software application |
CN108829437A (en) * | 2018-06-29 | 2018-11-16 | 北京金山安全软件有限公司 | Product development method, system, device, computer equipment and storage medium |
Families Citing this family (16)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US6470493B1 (en) * | 1999-09-30 | 2002-10-22 | Compaq Information Technologies Group, L.P. | Computer method and apparatus for safe instrumentation of reverse executable program modules |
US6957421B2 (en) * | 2001-01-26 | 2005-10-18 | Hewlett-Packard Development Company, L.P. | Providing debugging capability for program instrumented code |
US6918110B2 (en) * | 2001-04-11 | 2005-07-12 | Hewlett-Packard Development Company, L.P. | Dynamic instrumentation of an executable program by means of causing a breakpoint at the entry point of a function and providing instrumentation code |
US6892379B2 (en) * | 2001-05-16 | 2005-05-10 | Sun Microsystems, Inc. | Methods and apparatus for use in aiding stack unwinding |
US7082597B2 (en) * | 2001-06-20 | 2006-07-25 | Sun Microsystems, Inc. | Representation of objects in a Java programming environment |
US7036120B2 (en) * | 2001-07-31 | 2006-04-25 | Sun Microsystems, Inc. | Two tier clusters for representation of objects in Java programming environments |
US7017153B2 (en) * | 2001-12-13 | 2006-03-21 | Hewlett-Packard Development Company, L.P. | Uninstrumenting in-line code instrumentation via stack unwinding and cleanup |
US6993750B2 (en) * | 2001-12-13 | 2006-01-31 | Hewlett-Packard Development Company, L.P. | Dynamic registration of dynamically generated code and corresponding unwind information |
US7131115B2 (en) * | 2002-03-25 | 2006-10-31 | Hewlett-Packard Development Company, L.P. | Unwinding instrumented program code |
US7484205B2 (en) * | 2002-12-12 | 2009-01-27 | Microsoft Corporation | Preprocessor-based source code instrumentation |
US20050071606A1 (en) * | 2003-09-30 | 2005-03-31 | Roman Talyansky | Device, system and method of allocating spill cells in binary instrumentation using one free register |
US7624304B2 (en) * | 2004-10-07 | 2009-11-24 | Microsoft Corporation | Defect detection for integers |
US7676795B2 (en) * | 2005-01-13 | 2010-03-09 | International Business Machines Corporation | Error detection in a data processing system |
US7676796B2 (en) * | 2005-09-29 | 2010-03-09 | Intel Corporation | Device, system and method for maintaining a pre-defined number of free registers within an instrumented program |
US8732672B2 (en) * | 2005-12-15 | 2014-05-20 | International Business Machines Corporation | Constraint derivation in context following for use with object code insertion |
US8024710B2 (en) * | 2007-04-27 | 2011-09-20 | Microsoft Corporation | Unwinding unwindable code |
Citations (11)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5539907A (en) * | 1994-03-01 | 1996-07-23 | Digital Equipment Corporation | System for monitoring computer system performance |
US5732273A (en) * | 1995-08-11 | 1998-03-24 | Digital Equipment Corporation | System for monitoring compute system performance |
US5926832A (en) * | 1996-09-26 | 1999-07-20 | Transmeta Corporation | Method and apparatus for aliasing memory data in an advanced microprocessor |
US5966537A (en) * | 1997-05-28 | 1999-10-12 | Sun Microsystems, Inc. | Method and apparatus for dynamically optimizing an executable computer program using input data |
US6081665A (en) * | 1997-12-19 | 2000-06-27 | Newmonics Inc. | Method for efficient soft real-time execution of portable byte code computer programs |
US6293712B1 (en) * | 1997-09-30 | 2001-09-25 | Institute For The Development Of Emerging Architectures, Llc | Method and apparatus for constructing a stack unwind data structure |
US6314558B1 (en) * | 1996-08-27 | 2001-11-06 | Compuware Corporation | Byte code instrumentation |
US6327704B1 (en) * | 1998-08-06 | 2001-12-04 | Hewlett-Packard Company | System, method, and product for multi-branch backpatching in a dynamic translator |
US6327699B1 (en) * | 1999-04-30 | 2001-12-04 | Microsoft Corporation | Whole program path profiling |
US6339832B1 (en) * | 1999-08-31 | 2002-01-15 | Accenture Llp | Exception response table in environment services patterns |
US6470493B1 (en) * | 1999-09-30 | 2002-10-22 | Compaq Information Technologies Group, L.P. | Computer method and apparatus for safe instrumentation of reverse executable program modules |
Family Cites Families (1)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
JP3320358B2 (en) * | 1998-06-18 | 2002-09-03 | インターナショナル・ビジネス・マシーンズ・コーポレーション | Compiling method, exception handling method, and computer |
-
1999
- 1999-09-30 US US09/410,388 patent/US6470493B1/en not_active Expired - Fee Related
-
2002
- 2002-09-06 US US10/237,449 patent/US20030014737A1/en not_active Abandoned
Patent Citations (11)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5539907A (en) * | 1994-03-01 | 1996-07-23 | Digital Equipment Corporation | System for monitoring computer system performance |
US5732273A (en) * | 1995-08-11 | 1998-03-24 | Digital Equipment Corporation | System for monitoring compute system performance |
US6314558B1 (en) * | 1996-08-27 | 2001-11-06 | Compuware Corporation | Byte code instrumentation |
US5926832A (en) * | 1996-09-26 | 1999-07-20 | Transmeta Corporation | Method and apparatus for aliasing memory data in an advanced microprocessor |
US5966537A (en) * | 1997-05-28 | 1999-10-12 | Sun Microsystems, Inc. | Method and apparatus for dynamically optimizing an executable computer program using input data |
US6293712B1 (en) * | 1997-09-30 | 2001-09-25 | Institute For The Development Of Emerging Architectures, Llc | Method and apparatus for constructing a stack unwind data structure |
US6081665A (en) * | 1997-12-19 | 2000-06-27 | Newmonics Inc. | Method for efficient soft real-time execution of portable byte code computer programs |
US6327704B1 (en) * | 1998-08-06 | 2001-12-04 | Hewlett-Packard Company | System, method, and product for multi-branch backpatching in a dynamic translator |
US6327699B1 (en) * | 1999-04-30 | 2001-12-04 | Microsoft Corporation | Whole program path profiling |
US6339832B1 (en) * | 1999-08-31 | 2002-01-15 | Accenture Llp | Exception response table in environment services patterns |
US6470493B1 (en) * | 1999-09-30 | 2002-10-22 | Compaq Information Technologies Group, L.P. | Computer method and apparatus for safe instrumentation of reverse executable program modules |
Cited By (12)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20030115561A1 (en) * | 2001-12-13 | 2003-06-19 | Robert Hundt | Lazy and precise update of unwind information for dynamically generated code |
US6996810B2 (en) * | 2001-12-13 | 2006-02-07 | Hewlett-Packard Development Company, L.P. | Lazy and precise update of unwind information for dynamically generated code |
US20080065872A1 (en) * | 2003-06-23 | 2008-03-13 | Ju Dz-Ching | Methods and apparatus for preserving precise exceptions in code reordering by using control speculation |
US8769509B2 (en) * | 2003-06-23 | 2014-07-01 | Intel Corporation | Methods and apparatus for preserving precise exceptions in code reordering by using control speculation |
US20070038975A1 (en) * | 2005-08-15 | 2007-02-15 | Sony Ericsson Mobile Communications Ab | Systems, methods and computer program products for safety checking executable application programs in a module |
US8381198B2 (en) * | 2005-08-15 | 2013-02-19 | Sony Ericsson Mobile Communications Ab | Systems, methods and computer program products for safety checking executable application programs in a module |
US20100275185A1 (en) * | 2009-04-24 | 2010-10-28 | Felix Burton | System and Method for High Performance Coverage Analysis |
US20110167248A1 (en) * | 2010-01-07 | 2011-07-07 | Microsoft Corporation | Efficient resumption of co-routines on a linear stack |
US9003377B2 (en) * | 2010-01-07 | 2015-04-07 | Microsoft Technology Licensing, Llc | Efficient resumption of co-routines on a linear stack |
US20120144375A1 (en) * | 2010-12-02 | 2012-06-07 | International Business Machines Corporation | Reversibly instrumenting a computer software application |
US8978018B2 (en) * | 2010-12-02 | 2015-03-10 | International Business Machines Corporation | Reversibly instrumenting a computer software application |
CN108829437A (en) * | 2018-06-29 | 2018-11-16 | 北京金山安全软件有限公司 | Product development method, system, device, computer equipment and storage medium |
Also Published As
Publication number | Publication date |
---|---|
US6470493B1 (en) | 2002-10-22 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US6470493B1 (en) | Computer method and apparatus for safe instrumentation of reverse executable program modules | |
KR101719635B1 (en) | A system and method for aggressive self-modification in dynamic function call systems | |
US5124989A (en) | Method of debugging a computer program | |
US6874138B1 (en) | Method and apparatus for resuming execution of a failed computer program | |
US20040054991A1 (en) | Debugging tool and method for tracking code execution paths | |
JPS6482258A (en) | Apparatus and method for restoring page missing disturbance for vector data processing computation | |
EP0495165A3 (en) | Overlapped serialization | |
EP1118940A3 (en) | Bytecode program interpreter apparatus and method with pre-verification of data type restrictions | |
US20120198424A1 (en) | Providing Programming Support to Debuggers | |
US7761744B2 (en) | Debugging method | |
US6892379B2 (en) | Methods and apparatus for use in aiding stack unwinding | |
US20040044930A1 (en) | System and method for controlling activity of temporary files in a computer system | |
US20040068480A1 (en) | Method and apparatus for initializing romized system classes at virtual machine build time | |
US5150474A (en) | Method for transferring arguments between object programs by switching address modes according to mode identifying flag | |
JP2817786B2 (en) | Simulation apparatus and simulation method | |
WO2000065440A3 (en) | Exception handling method and apparatus for use in program code conversion | |
JPH0731617B2 (en) | Program runaway detection method | |
AU1490888A (en) | Apparatus and method for synchronization of arithmetic exceptions in parallel pipelined execution units | |
US7080231B2 (en) | Processor with tagging buffer and methods for avoiding memory collisions | |
JPS6312027A (en) | Job control language expert system | |
JPH03235135A (en) | Automatic inspection system for program | |
JP2800577B2 (en) | Debug device | |
Thomas | Garbage collection in shared-environment closure reducers: Space-efficient depth first copying using a tailored approach | |
JPH1040131A (en) | Program debug method | |
JPH08320813A (en) | Program simulator device and program debugging method |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
AS | Assignment |
Owner name: HEWLETT-PACKARD DEVELOPMENT COMPANY, L.P., TEXAS Free format text: CHANGE OF NAME;ASSIGNOR:COMPAQ INFORMATION TECHNOLOGIES GROUP, L.P.;REEL/FRAME:017095/0540 Effective date: 20021001 |
|
STCB | Information on status: application discontinuation |
Free format text: ABANDONED -- FAILURE TO RESPOND TO AN OFFICE ACTION |