Method and apparatus for a fast debugger fix and continue operation

• US 5,675,803 A
• Filed: 09/01/1994
• Issued: 10/07/1997
• Est. Priority Date: 01/28/1994
• Status: Expired due to Term

• Current Assignee: Sun Microsystems Incorporated (Oracle Corporation)
• Original Assignee: Sun Microsystems Incorporated (Oracle Corporation)
• Inventors: Preisler, Thomas, Pelegri-Llopart, Eduardo, Miller, Terrence C., Gramlich, Wayne C.
• Primary Examiner(s): Kriess, Kevin A.
• Assistant Examiner(s): Chavis, John Q.
• Application Number:
  US08/299,720
• Time in Patent Office: 1,132 Days
• Field of Search: 395/650, 395/700
• US Class Current: 717/131
• CPC Class Codes: G06F 11/3624 by performing operations on the source code, e.g. via a compiler
• CPC Class Codes: G06F 11/3644 by instrumenting at runtime

Abstract

This Continuation-In-Part describes a part of this run-time debugger operation which is designated the "Fix-and-Continue" invention. This invention permits a user to begin a debugging session wherein if an error in the code is encountered, the user can edit the corresponding source code to correct the error and then execute a "Fix and Continue" command all without leaving the debugging session. The Fix and Continue code calls the compiler to recompile the source code file with the edited text in it, receives the resulting recompiled object code file from the compiler, uses the dynamic linker to link the recompiled object code into the target application program process, patches the previous version of this same object code fie to refer to the newly recompiled code, resets any required variables and registers, resets the program counter to the line of code being executed when the error was discovered. The debugger then continues in the debug session thereby saving the time it would ordinarily take to quit the debug session, relink and reload the target program and start the debug session once again.

Claims

1. A method for debugging a computer application program on a computer system which includes a processor, a program counter, memory and program instructions, the method being designed to allow generation and insertion of corrective program instructions while continuing a debugging session, the method being implemented by said program instructions and comprising the steps of:

detecting an error in said computer application program, which is executing during a debugging session, in said computer system'"'"'s memory;

dynamically fixing program code which contains said error without terminating said debugging session; and

continuing the debugging session with said fixed program code by continuing said debugging session where said error occurred,

whereby the program error was corrected without stopping the debugging session in order to recompile an entire program.

2. The method for debugging a computer application program of claim 1 wherein said step of fixing program code which contains said error without terminating said debugging session comprises the additional steps of:

calling a compiler and passing to the compiler a file of edited source code containing edits to correct said error;

receiving from the compiler a recompiled object code file corresponding to said file of edited source code;

creating a dynamic library file corresponding to said recompiled object code file;

linking said dynamic library file to said computer application program;

dynamically patching the computer application program to point to said dynamic library file;

resetting the program counter; and

moving break points to said recompiled object code file.

3. The method for debugging a computer application program of claim 2 wherein said step of resetting the program counter comprises the additional step of resetting the program counter to a location corresponding to a beginning of a same line in the recompiled object code file which corresponds to a specific line in the corresponding previous version of the object code wherein the error occurred in executing said specific line, if a function containing said same line was not modified in said recompiled object code file.

4. The method for debugging a computer application program of claim 2 wherein said compiler is configured to globalize static variables in said file of edited source code containing edits to correct said error, to provide data relating to constructors and destructors in said file of edited source code containing edits to correct said error and to provide data relating to floating point register settings in said file of edited source code containing edits to correct said error.

17. The method for debugging a computer application program of claim 1 wherein said step of fixing program code which contains said error without terminating said debugging session comprises the additional step of popping one or more frames from a stack containing data corresponding to said function containing said same line and setting the program counter to a location of a statement that called said function, if said function containing said same line was modified in said recompiled object code file.

5. A method for debugging a computer application program on a computer system which includes a processor, a program counter, memory and program instructions, the method being designed to allow generation and insertion of corrective program instructions while continuing a debugging session, the method being implemented by said program instructions and comprising the steps of:

loading a debugger computer program into said memory;

loading source code and object code for a compiled computer application program into said memory;

requesting said debugger computer program to begin a run-me execution of said compiled computer application program object code;

executing a fix and continue routine in said debugger computer program if an error is found, wherein a source code file containing said error is edited, recompiled and recompiled object code for said source code file containing said error is dynamically patched into previously loaded object code of said compiled computer application program; and

said debugger restarting said run-time execution of said compiled computer application program object code which has been edited wherein said restart occurs in an area of said recompiled object code where said error was detected,

whereby the program error was corrected without stopping the debugging session in order to recompile an entire program.

6. The method for debugging a computer application program of claim 5 wherein said object code for a compiled computer application program is generated using an enhanced compiler whereby object code produced by the compiler contains debugging aids.

7. The method for debugging a computer application program of claim 6 wherein said debugging aids comprises globalization of static variables.

8. The method for debugging a computer application program of claim 7 wherein said debugging aids further comprises data to permit restoration of floating point registers.

9. The method for debugging a computer application program of claim 7 wherein said debugging aids further comprises data to permit execution of constructor and destructor commands as required to restore variable contents to correct values upon restarting run-time debugging.

10. The method for debugging a computer application program of claim 5 wherein said step of executing a fix and continue routine in said debugger computer program if an error is found comprises the additional steps of:

calling a compiler and passing to the compiler a file of edited source code containing edits to correct said error;

receiving from the compiler a re, compiled object code file corresponding to said file of edited source code;

linking said recompiled object code file to a corresponding previous version of said object code file;

resetting the program counter;

moving break points to said recompiled object code file; and

restarting said application program at the point indicated by the program counter wherein the debugging process continues.

11. The method for debugging a computer application program of claim 10 wherein said step of linking said recompiled object code file to a corresponding previous version of said object code file comprises the additional step of patching an entry location of a function code section in said previous version of said object code file to point to a corresponding entry location of a corresponding function code section in said recompiled object code file.

12. The method for debugging a computer application program of claim 10 wherein said step of resetting the program counter comprises the additional steps of:

resetting the program counter to a location corresponding to a beginning of a same line in the recompiled object code file which corresponds to a specific line in the previous version of the object code wherein the error occurred in executing said specific line, if a function containing said same line was not modified in said recompiled object code file; and

popping one or more frames from a stack containing data corresponding to said function containing said same line and setting the program counter to a location of a statement that called said function, if said function containing said same line was modified in said recompiled object code file.

13. A computer system for debugging a computer application program, the system being designed to allow generation and insertion of corrective program instructions dynamically into the computer application program while continuing a debugging session, the computer system comprising:

a processor having a program counter, memory and program instructions;

a debugger in said memory configured to detect an error in said computer application program during a debugging session, said debugging session executed by said processor; and

said debugger comprising;

a fix subsystem for dynamically repairing program code which contains said error without terminating said debugging session; and

a continue subsystem for restarting said debugging session where said error occurred using said repaired program code,

whereby the program error was corrected without stopping the debugging session in order to recompile an entire program.

14. The computer system for debugging a computer application program of claim 13 wherein said fix subsystem comprises:

a call mechanism configured to invoke a compiler and to pass to the compiler a file of edited source code containing edits to correct said error;

a communications mechanism configured to receive from the compiler a recompiled object code file corresponding to said file of edited source code;

a linking mechanism which can connect said recompiled object code file to a corresponding previous version of said object code file;

a program counter control mechanism which can modify said program counter; and

a break point placement mechanism which can move brake points from a previous object code File to said re, compiled object code file.

15. The computer system for debugging a computer application program of claim 14 wherein said program counter control mechanism comprises:

a first control device which can set the program counter to a location corresponding to a beginning of a same line in the re, compiled object code file which corresponds to a specific line in the corresponding previous version of the object code wherein the error occurred in executing said specific line, if a function containing said same line was not modified in said recompiled object code file; and

a second control device which can pop one or more frames from a stack containing data corresponding to said function containing said same line and thereafter set the program counter to a location of a statement that called said function, if said function containing said same line was modified in said recompiled object code file.

16. The computer system for debugging a computer application program of claim 14 wherein said compiler is configured to globalize static variables in said fie of edited source code containing edits to correct said error, to provide data relating to constructors and destructors in said file of edited source code containing edits to correct said error and to provide data relating to floating point register settings in said file of edited source code containing edits to correct said error.

18. A system for debugging a computer application program on a computer which includes a processor, a program counter, memory and program instructions, the system being designed to allow generation and insertion of corrective program instructions dynamically into the computer application program while continuing a debugging session, the system comprising:

means for detecting an error in said computer application program during a debugging session;

means for dynamically fixing program code which contains said error without terminating said debugging session; and

means for continuing the debugging session with said fixed program code by restarting said debugging session where said error occurred,

whereby the program error was corrected without stopping the debugging session in order to recompile an entire program.

19. A method for debugging a computer application program on a computer system which includes a processor, a program counter, memory and program instructions, the method being designed to allow generation and insertion of corrective program instructions dynamically into the computer application program while continuing a debugging session, the method being implemented by said program instructions in said memory and comprising the steps of:

detecting an error in said computer application program during a debugging session;

dynamically fining program code which contains said error without terminating said debugging session, said fixing operation permitting a user to specify that debug information should be added and permitting said user to modify a line of code to be fixed; and

continuing the debugging session with said fixed program code by restarting said debugging session where said error occurred,

whereby the program error was corrected without stopping the debugging session in order to recompile an entire program.

20. A computer program embodied on a computer-readable medium for enabling a system for debugging a computer application program, the system being designed to allow generation and insertion of corrective program instructions dynamically into the computer application program while continuing a debugging session, comprising:

a processor having a program counter, memory and program instructions;

a debugger in said memory configured to detect an error in said computer application program during a debugging session, said debugging session executed by said processor; and

said debugger comprising;

a fix subsystem which will allow a user to repair program code which contains said error without terminating said debugging session, said fix subsystem configured to permit said user to specify that debug information should be added and to permit said user to modify a line of code to be fixed; and

a continue subsystem which will allow the user to restart said debugging session where said error occurred using said repaired program code,

whereby the program error was corrected without stopping the debugging session in order to recompile an entire program.