Debugger apparatus and method having an event history recording capability
BACKGROUND OF THE INVENTION 
     1. Field of the Invention 
     The present invention relates to a debugger and a method of supporting a debug, for supporting a debug operation for a program used in a computer. 
     2. Description of the Related Art 
     Verification of a program used in a computer is performed by a static test, a dynamic test, or the like to determine whether the program satisfies required conditions. When a bug (incorrect behavior) in the program is detected by the above test, manual correction (i.e., debug) is performed by a programmer. 
     When an error is detected in the test, a code for error must be specified. There are some methods of specifying a bug portion. Of these methods, a method of back tracking of the program behavior is an effective method. In order to realize this method, a detailed instruction execution history obtained during execution of the program is required. For this reason, according to a conventional technique, in order to perform the back track of the program, a complete instruction execution history is sampled/recorded during execution of a debugging program. 
     However, when a debugging program is a program such as a concurrent or real-time program having nondeterministic characteristics, the overhead of a recording execution is increased upon completely sampling/recording an instruction execution history. For this reason, the behavior of the program performed when the instruction execution history is sampled/recorded is largely different from that performed when the instruction execution history is not sampled/recorded, and the bug portion detected during a test may not be reproduced. 
     In order to solve this drawback, at present, the following method is considered. The behavior of a program is recorded during execution of the debugging program, and the program is analyzed along the behavior of the recorded program, thereby forming an instruction execution history. However, according to this method, a long time is required for analyzing the program. 
     Therefore, in a debugging program, such as a concurrent or real-time program having nondeterministic characteristics, a detailed instruction execution history cannot be easily recorded or analyzed. 
     SUMMARY OF THE INVENTION 
     It is an object of the present invention to provide a debugger and a method of supporting a debug, wherein an instruction execution history required for reexecuting a program can be sampled/recorded without adversely affecting an execution of the program, and the back track and reexecution of the target program can be performed on thee basis of the recorded instruction execution history. More specifically, it is the object of the present invention to provide a debugger and a method of supporting a debug, wherein even when a debugging program such as a concurrent or real-time program having no reproducibility is used, an instruction execution history required for performing the back track of the program can be sampled/recorded without adversely affecting an execution of the program, the back track and reexecution of the debugging program can be freely performed on the basis of the recorded instruction execution history, and defective behavior detected during a test can be reproduced. 
     A debugger according to the present invention is characterized by: a user interface section for inputting an instruction from a user; an event history recording section for recording an event history of events occurring when a debugging program is executed; a program behavior reproducing section for controlling the debugging program in accordance with the event history to reexecute an execution corresponding to the debugging program; an instruction execution history recording section for recording an instruction execution history including all instructions executed when the execution corresponding to the debugging program and reproduced by the program execution reproducing means and contents of the memory and register before the instructions are executed; and an instruction execution history reproducing section for selectively performing a back track for recovering an internal state of the computer to a state, obtained prior to execution of at least one instruction of the debugging program, in accordance with the instruction execution history, and a reexecution, performed after the back track is performed, on the basis of an instruction from of the user interface section. 
     The preferable aspects of the present invention are as follows. 
     (a) The computer executes any one of a concurrent program and a program executed in real time as the debugging program. 
     (b) The event history recording section includes means for recording an access instruction for the memory as the event. 
     (c) The event history recording section has a table which records occurrence numbers sequentially added to the events each time each event has occurred, tasks of the debugging program, and contents of the events. 
     (d) The event history recording section includes means for recording addresses of the debugging program and instructions to be executed. 
     (e) When the recording area for the event history or the instruction execution history is not sufficient, the apparatus may further comprise storage means for storing at least one of the event history and the instruction execution history. 
     A debug supporting method according to the present invention is characterized by: a first step of recording an event history of events occurring when a debugging program is executed; a second step of controlling the debugging program in accordance with the event history to reexecute an execution corresponding to the debugging program; a third step of recording an instruction execution history including all instructions executed when the execution corresponding to the debugging program is reproduced and contents of the memory and register before the instructions are executed; and a fourth step of selectively performing a back track for recovering an internal state of the computer to a state, obtained prior to execution of at least one instruction of the debugging program, in accordance with the instruction execution history, and a reexecution, performed after the back track is performed, on the basis of an instruction content of a user. 
     According to a debugger and a method of supporting a debug according to the present invention, an event history is sampled/recorded by the event history recording section during execution of a target program. The debugging program is controlled using this event history, and an execution is reproduced, thereby sampling/recording an instruction execution history. Therefore, in the debugger and the method of supporting a debug according to the present invention, since a method of sampling only the event history used for reproducing the execution is employed during execution of the debugging program, an influence on the behavior of the debugging program can be considerably smaller than that obtained by using a method of sampling all instruction execution histories during execution of the debugging program. Therefore, the instruction execution history can be sampled from the debugging program without causing the overhead of the recording operation of the instruction execution history to adversely affect the debugging program. In addition, according to the debugger of the present invention, a back track and a reexecution can be selectively performed using the instruction execution history each time an instruction of the debugging program is executed. 
     As described above, in the debugger and the method of supporting a debug according to the present invention, a debugging program is executed while an event history is sampled, and when incorrect behavior is detected, the execution of the target program for debug is controlled using the event history to reproduce the execution of the program. Therefore, the instruction execution history of the reproduced debugging program can be recorded while the influence of overhead caused by the recording operation is eliminated. The back track and reexecution of the debugging program can be performed using the recorded instruction execution history. 
     As described above, in the debugger and the method of supporting a debug according to the present invention, events can be easily sampled, and a incorrect behavior detected during a test can be easily reproduced without adversely affecting execution of a program. 
     Additional objects and advantages of the present invention will be set forth in the description which follows, and in part will be obvious from the description, or may be learned by practice of the present invention. The objects and advantages of the present invention may be realized and obtained by means of the instrumentalities and combinations particularly pointed out in the appended claims. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     The accompanying drawings, which are incorporated in and constitute a part of the specification, illustrate presently preferred embodiments of the present invention and, together with the general description given above and the detailed description of the preferred embodiments given below, serve to explain the principles of the present invention in which: 
     FIG. 1 is a block diagram showing the arrangement of a debugger according to an embodiment of the present invention; 
     FIG. 2 view showing an event history recording table in an event history recording section in FIG. 1; 
     FIG. 3 is a view showing an instruction execution history recording table in an instruction execution history recording section incorporated in the apparatus of the present invention; 
     FIG. 4 is a view showing a debugging program; 
     FIG. 5 is a view showing the flow of the debugging program; 
     FIG. 6 is a flow chart showing an execution of the event history recording section incorporated in the apparatus of the present invention; 
     FIG. 7 is a flow chart showing processing in a case wherein the event recording area has no unused area; 
     FIG. 8 is a flow chart showing an operation of a program behavior reproducing section incorporated in the apparatus of the present invention; 
     FIG. 9 is a flow chart showing an operation of the instruction execution history recording section; and 
     FIG. 10 is a flow chart showing an operation of the instruction execution history reproducing section incorporated in the apparatus of the present invention. 
    
    
     DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS 
     An embodiment will be described below with reference to the accompanying drawings. 
     FIG. 1 is a block diagram showing the arrangement of a debugger according to an embodiment of the present invention. FIG. 1 shows an example wherein a debugger 10 samples information for debug from a time sharing debugging program 20 (i.e., a program undergoing a debug operation). Referring to FIG. 1, a flow of data is indicated by arrows of solid lines, and a flow of control is indicated by arrows of dotted lines. In FIG. 1, a user interface section 30 comprises a display section and an input/output section (neither are shown), and performs communication between a user and the debugger 10. A storage section 35 stores an event history and an instruction execution history (to be described later) as needed. 
     The debugger 10 has an event history recording section 12, a program behavior reproducing section 14, an instruction execution history recording section 16, and an instruction execution history reproducing section 18. 
     The event history recording section 12 sequentially records events in an event history recording table 40 shown in FIG. 2. In this case, the events represent instructions such as an access instruction for the memory in FIG. 2 and an input/output instruction between the event history recording section 12 and an external apparatus, for switching a program, e.g., inputting an external signal. In FIG. 1, although the event history recording section 12 is arranged to be called by the debugging program 20 when an event occurs in execution of the debugging program 20, the event history recording section 12 may always be set in an active state. 
     The event history recording section 12 records, as shown in FIG. 2, event numbers, the names of tasks in which events have occurred, the contents of the events (event occurrence addresses and detailed contents) in the event history recording table 40. In this embodiment, executions such as &#34;access to global variable&#34; and &#34;completion of task execution&#34; which influence executions between tasks are recorded as events. 
     The program behavior reproducing section 14 reproduces an execution of the debugging program 20 in accordance with an instruction from the user interface section 30 using an event history recorded in the event history recording table 40 of the event history recording section 12. While the debugging program 20 is reproduced by the program behavior reproducing section 14, the instruction execution history recording section 16 records an instruction execution history in an instruction execution history recording table 42 shown in FIG. 3 under the control of the program behavior reproducing section 14. In the instruction execution history recording section 16, the instruction numbers of executed instructions, task names, the contents of a register or a memory prior to changes in contents, and address pointers obtained prior to changes in address pointers are recorded in the instruction execution history recording table 42. 
     The instruction execution history reproducing section 18 recovers the state of the debugging program 20 to a state obtained before an instruction is executed, in accordance with an instruction from the user interface section 30 using the instruction execution history recorded in the instruction execution history recording table 42. 
     An example of the target debugging program 20 is shown in FIG. 4. 
     Task A is an initialization program and initializes global variables GV0 and GV1. Task B and Task C are tasks having the same contents, and concurrently perform an operation of exclusively reading the value of the global variable GV0 using a system call SYS1 and an operation of adding this value to a local variable LVB1 (LVC1). The system call SYS1 is a system call for atomically performing two operations of returning the value of the global variable GV0 to an AX register and of subtracting 1 from the value of the global variable GV0 (without dispatching). Therefore, the value of the variable GV0 returned by the system call SYS1 is decremented by one each time the two operations are performed. 
     The global variable GV0 is a variable for managing a value to be added to the local variables of the two tasks (Task B and Task C) which are concurrently operated and represent a value to be added when the system call SYS1 is called next. The global variable GV1 is a flag representing the completion of initialization of the global variable GV0. In the global variable GV1, 0 represents that initialization is completed, 1 represents that initialization is being performed, and &#34;*event*&#34; represents that the instruction of a line having &#34;*event*&#34; is an event to be recorded in the event history recording table 40. 
     In the debugging program 20, after Task A initializes the global variable, the value of the global variable GV0 is added to each of the local variables of Task B and Task C. The value of the global variable GV0 is decreased each time the system call SYS1 for adding the value to the local variable is called, and the value is finally set to be -1. When the value of the global variable GV0 read out by the system call SYS1 is 1 or less, the executions of the corresponding task (i.e., one of Task A and Task B which reads the GV0) is completed. As a result, the sum of the initial values, i.e., 4 to 0 of the global variable GV0 is calculated such that sums of two local variables (LVB1 and LVC1) are calculated, and the sum of the local variables LVB1 and LVC1 becomes 10. 
     The above debugging program 20 has the following disadvantage. Task B or Task C is operated before the global variable GV0 is initialized, and Task B or Task C is abnormally operated when the global variable GV1 is set to be 0. 
     A sequence for causing the debugger 10 to sample debug information from the debugging program 20 will be described below with reference to FIGS. 4, 5, and 6. 
     Assume that the global variable GV0 is set to be 1, and the global variable GV1 is set to be 0 before initialization is performed in Task A. In this state, a case wherein the execution of the debugging program 20 is started, i.e., a case wherein Task C is started and the execution is started from address 2010 will be described below. 
     An event for reading the global variable GV1 serving as an initialization flag occurs at address 2020. An event occurrence task (Task C) and the contents of the event (in this case, the global variable GV1 is read at address 2020) are recorded in the event history recording table 40 (steps A1 and A2). An event recording pointer is moved to the next pointer (step A3), thereby completing the recording of an event history. 
     In this case, in step A3, when an event recording area is full, the execution shown in FIG. 7 is performed. 
     All the contents of events recorded in the event recording area are stored in the storage section 35 (step B1). The pointer is moved to the uppermost portion (start position) of the event recording area (step B2). 
     With the above execution, even when the event recording area is full, all the contents of the events can be recorded. 
     when the global variable GV1 is examined (address 2030), the completion of initialization is determined (since GV1=1 is set before initialization is performed, erroneous determination is performed) (address 2040), and the value, i.e., 1 of the variable GV0 is added to a local variable at address 2050. Since an event has occurred at address 2050, steps A1 to A3 are executed to record the contents of the events in the event history recording table 40 as in the case of address 2020. 
     At this time, assume that switching of tasks has occurred by scheduling of time slices such that Task C is switched to Task A. Although Task A starts initialization, when Task A is switched to Task B during the initialization (address 30), Task B reads the global variable GV1 serving as an initialization flag at address 1020. At this time, since the global variable GV1 is being initialized (GV1=1), a loop is repeated (address 1040). 
     When Task B is switched to Task C again, a received task (GV0=1) is determined (address 2080) as a final remaining task, and Task C is ended. 
     When Task C is switched to Task A, initialization of Task A is completed, and Task A is ended. When Task A is switched to Task B, Task B singly reproduces an execution (the value of the variable GV0 is read by the system call SYS1 so as to be added to the local variable). As a result, the value of LVB1 becomes 10, the value of LVC1 becomes 1, and the sum of these values does not become 10 but 11. 
     In the execution described above, the event history recording section 12 records the contents of each event in the event history recording table 40 each time an event occurs. 
     By using the event history recorded in the event history recording table 40 as described above, a reexecution of the debugging program 20 performed by the instruction execution history recording section 16 and an operation of recording the .instruction execution history shown in FIG. 3 performed by the instruction execution history recording section 16 will be described with reference to FIGS. 8 and 9. 
     When the program behavior reproducing section 14 reads out an event history corresponding to one line from the event history recording table 40 (step C1), since an event (number 1: read GV1 at address 2020 of Task C) is recorded in the event history recording table 40, the instruction execution history recording section 16 is operated, and Task C is executed from address 2010 (steps C2, C3, and C4). 
     The instruction execution history recording section 16 performs the following execution in every step of performing the reexecution of the program. The instruction execution history recording section 16 reads out an instruction to be executed, and records a task name, the original value (indefinite) of LVC1, and an instruction address in the instruction execution history recording table 42 to substitute LVC1 for 0 at, e.g., address 2010, (steps D1 and D2). In steps D1 and D2, the instruction execution history recording section 16 necessarily records a task name and an instruction address in the instruction execution history recording table 42 each time an instruction is executed. As in step A3 shown in FIG. 6, an instruction history recording pointer is moved to the next pointer (step D3), an instruction history corresponding to one step is ended. In step D3, if the instruction history recording area is full, instruction histories are sequentially recorded in the storage section 35, thereby sampling all the records. 
     When address 2020 of Task C is executed, since the value is substituted in the AX register, the original value (indefinite) is recorded in the instruction execution history recording table 42. This means that the event (number 1: read GV1 at address 2020 of Task C) recorded in the event history recording table 40 occurs (steps C5 and C6). 
     When the event recorded next is loaded from the event history recording table 40 (step C1), since this is an event (number 2: read GV0, GV0=GV0-1 at address 2050 of Task C), Task C is continuously executed (steps C2 to C4). Since the content of a flag register is changed at address 2030, the original value of the flag register is recorded. 
     As the result of the branch processing at address 2040, control is shifted to address 2050. Since the AX register and GV0 are changed at address 2050, the contents of the AX register and GV0 are recorded in the instruction execution history recording table 42. This means that the event (number 2: read GV0, GV0=GV0-1 at address 2050 of Task C) recorded in the event history recording table 40 has occurred (steps C5 and C6). 
     When the event recorded next is read from the event history recording table 40 (step C1), since this event is an event (number 3: write GV1 at address 10 of Task A) of Task A, a register or the like saved in advance is restored, and the task is switched to Task A. Task A is executed from address 10 (steps C2 to C4). 
     when the operations of steps C1 to C6 are reproduced, the instruction execution history recording table 42 can be obtained. 
     When the instruction execution history reproducing section 18 performs the operation shown in FIG. 10 using the instruction execution history recording table 42, the back track of a debugging program can be performed. The back track is a behavior of recovering the state of the program to the original state as if the instructions of the program are executed in the reverse direction. 
     It is checked whether an instruction execution history is present (step E1). If it is confirmed that the instruction execution history is present, the instruction execution history is read (step E2). A register memory is recovered to the state prior to execution of the instruction each time the instruction execution history is read out (step E3). In this manner, the back track of the debugging program can be performed. More specifically, an example wherein the back track of the 16th instruction to the 13th instruction in FIG. 3 is performed will be described below. 
     When an instruction at address 2080 of Task C is executed, the back track is started using a result obtained by executing the 16th instruction of the instruction execution history recording table 42 in FIG. 3. 
     In viewing the result obtained by executing the 16th instruction, there are no register and memory whose values are changed. For this reason, IP is set at address 2080. In addition, when the back track of the debugging program is performed using the result obtained by executing the 15th instruction, since it is recorded that the zero flag of the flag register is 1, the zero flag of the flag register is set to be 1, and IP is set at address 2070. The local variable LVC1 is set to be 0, IP is set at address 2060, and the back track of the next one step (14th instruction) is executed. 
     Since a result obtained by executing Task B is recorded as the result obtained by executing the 13th instruction, the register or the like of saved Task B is restored, the AX register is set to be 1, and IP is set at address 1020. 
     In order to perform the reexecution of the debugging program, the program may be executed again using the event execution history by the program behavior reproducing section 14 because the internal state of the program is completely recovered to an original state. The reexecution is defined as an execution in which, after the back track of the program is performed, in this state, the program is operated again in a normal direction. 
     As described above, all information required for a debug operation for the debugging program can be easily obtained. Therefore, according to the present invention, an instruction execution history required for performing the back track of the program can be sampled/recorded without adversely affecting the execution of the program. The back track and reexecution of the target program can be performed on the basis of the recorded instruction execution history. 
     Additional advantages and modifications will readily occur to those skilled in the art. Therefore, the present invention in its broader aspects is not limited to the specific details, representative devices, and illustrated examples shown and described herein. Accordingly, various modifications may be made without departing from the spirit or scope of the general inventive concept as defined by the appended claims and their equivalents.