JP2000315166A - Software debugging device - Google Patents

Abstract

PROBLEM TO BE SOLVED: To detect the updating of a variable value and to check a value obtained before updating without exerting influence upon the execution of a program. SOLUTION: The software debugging device is provided with a debugger part 120, an emulator part 121 and an output device 109. The emulator part 121 is provided with an emulation memory 101 for storing data or the like included in a program and a coverage memory 102 for recording the status of an access to the memory 101 due to the execution of the program, The debugger part 120 is provided with a coverage status monitoring part 110 for monitoring the memory 102 and the access status to the memory 101 due to the execution of the program. The monitoring part 110 acquires access status from an address of the memory 102, detects whether the value of a variable is updated or not on the basis of the access status and allows a display part to display corresponding contents.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a source debugger used for debugging a source program described in a high-level language such as C language, and more particularly, to detecting a change in a specific variable value in a source program. The present invention relates to a software debugging device that has made it possible.

[0002]

2. Description of the Related Art A conventional software debugging device will be described with reference to FIG. In FIG. 1, a load module 100 in a host machine 1 compiles and links a source program created by a user in a high-level language such as C language, and translates the source program into a machine language including various information for debugging. . The variable information table 103 stores variable information (symbol information such as variable type and address) of each variable in the source program acquired from the debug information in the load module 100. The latest data storage unit 104 stores the latest value of each variable obtained from the emulation memory 101 in the emulator unit 121 based on the address information of each variable stored in the variable information table 103. The emulation memory 101 stores a program (load module 1) created by the user by the emulation unit 122.
00) and data. The old data storage unit 105 stores the values of variables before the contents of the latest data storage unit 104 are updated by executing the program. The data comparison unit 111 compares the variable values of the latest data storage unit 104 and the old data storage unit 105 for each variable, and notifies the variable value display unit 107 of the presence or absence of a change. The output device 109 displays the value of the variable acquired by the variable value display unit 107 from the latest data storage unit 104.

The operation of the software debug device having such a configuration will be described with reference to the flowchart of FIG. FIG. 8A shows a variable which the user wants to monitor the value among variables existing in the source program.
This is a process when an operation is performed so as to be displayed in FIG. First,
The user performs an operation of displaying a variable whose value is to be monitored on the output device 109 (step B1). Then, the information (symbol information such as type and address) of the variable specified in step B1 is acquired from the debug information in the load module 100 and stored in the variable information table 103 (step B2). Further, since it is possible to know to which address in the emulation memory 101 a variable is assigned from the address information of each variable stored in the variable information table 103, the emulation / decoding is performed based on the address value. The latest value of each variable is read from the memory 101 and stored in the latest data storage unit 104 (step B3). Then, the variable value display unit 107
Outputs the value of each variable stored in the latest data storage unit 104 to the output device 109 (step B4).

FIG. 8B shows a process when the user performs an operation for executing the source program. The output device 109 is executed by the process shown in the flowchart of FIG.
This is the process performed for the variables displayed in the above. When the execution of the source program is prompted by the user, the source program is executed up to the position designated by the user or to the point where the execution stop instruction is issued. After the execution of the program is completed, first, before acquiring the latest value of each variable from the emulation memory 101 in which the content of the latest data storage unit 104 has been updated by the execution of the program, the oldest data storage unit 105 stores the latest data storage unit. Save the contents of 104 (the values of each variable before execution) (step B
7). After the processing of step B7 is completed, emulation
The latest value of each variable is obtained from the memory 101 and stored in the latest data storage unit 104 (step B8). Next, the data comparison unit 111 compares the variable values of the latest data storage unit 104 and the old data storage unit 105 for each variable (step B9), and notifies the variable value display unit 107 of the presence or absence of a change. When there is a change in the value, the variable value display unit 107 displays the value of the variable acquired from the latest data storage unit 104 on the output device 109 by changing the display color (step B10 & step B4). If there is no change, the display is performed without changing the display color (step B4).

Next, as will be described in detail later, the source
Using the program, the variable information table of FIG.
From the display example of (a), taking the variables count and zero as an example, the operation when there is no change in the value due to the execution of the program and when there is a change will be described. In the source program of FIG. 3, it is assumed that the user performs a process of displaying the variable count on the output device 109 when the execution is performed up to the ninth line. Also, assume that the value of the variable count at this point is “3”. When the user performs a process of displaying the variable count on the output device 109, the debugger unit 120 first
The symbol information of the variable count acquired from the debug information in the load module 100 is stored in the variable information table 10.
Register to 3.

Next, the value “3” of the address 0x10E (the address stored in the variable information table 103) is read from the emulation memory 101 and stored in the latest data storage unit 104. The variable value display unit 107 displays the value “3” of the variable count stored in the latest data storage unit 104 on the output device 109 without changing the display color. here,
It is assumed that the user performs an operation of executing the tenth line to stop the program. After the execution is completed, the latest data storage unit 104
Then, the value “3” before the program is executed is saved in the old data storage unit 105. After saving the value before executing the program, the address 0x10 is saved from the emulation memory 101.
The value “3” of E is read and stored in the latest data storage unit 104. Next, the data comparison unit 111 compares the value of the variable “count” between the latest data storage unit 104 and the old data storage unit 105. The variable value display unit 107 stores the latest data storage unit 104
From the data comparison unit 1
As a result of comparing the old and new values at 11, the values are the same, so that the variable value “3” is displayed on the output device 109 without changing the display color.

Next, it is assumed that the user performs an operation to execute the eleventh line and stop the program. After the execution ends,
The value “3” before the execution of the program is saved from the latest data storage unit 104 to the old data storage unit 105. After saving the values before program execution, the emulation memory 101
The value “4” of the address 0x10E is read out from the memory and stored in the latest data storage unit 104. Next, the latest data storage unit 10
4 and the value of the variable count of the old data storage unit 105 are compared by the data comparison unit 111. The variable value display unit 107 acquires the value “4” (the value after execution) from the latest data storage unit 104, and compares the new and old values with the data comparison unit 111. The variable value “4” is displayed on the output device 109.

[0008] Here, the user sets the variable zero to the output device 10.
It is assumed that a process for displaying the image on the screen 9 has been performed. The value of the variable zero at the time when the execution is completed up to the eleventh line is “0”. At this time, the debugger 120 first loads the load module 1
The symbol information of the variable zero acquired from the debug information in 00 is registered in the variable information table 103. further,
Address 0x112 from emulation memory 101
(Address stored in variable information table 103)
Is read out and stored in the latest data storage unit 104. The variable value display unit 107 stores the latest data storage unit 104
Is displayed on the output device 109 without changing the display color.

[0009] Further, it is assumed that the user performs an operation of executing the thirteenth line to stop the program. After the execution is completed, the value “0” before the execution of the program is saved from the latest data storage unit 104 to the old data storage unit 105. After saving the value before the program is executed, the value “0” at the address 0x112 is read from the emulation memory 101 and stored in the latest data storage unit 104. Next, the latest data storage unit 104
And the value of the variable count of the old data storage unit 105 are compared by the data comparison unit 111. The variable value display unit 107 obtains “0” (the value after execution) from the latest data storage unit 104 and compares the old and new values by the data comparison unit 111. As a result, the values are the same, so that the display color is not changed. The variable value “0” is displayed on the output device 109.

[0010]

However, such a conventional software debug device has the following problems. The first problem is that the same value, for example, a change from “0” to “0” cannot be detected as in the example of the variable variable zero described above. The reason is that the change of the value of the variable is judged by comparing the value of the latest variable with the value of the variable before executing the program, so when the value changes to the same value, the change of the value of the variable can not be detected That's why. Therefore, it is not possible to determine whether the value of the variable in the program has been updated. The second problem is that the values before the program is executed cannot be displayed. The reason is that there is no means for displaying old data. Therefore, when trying to check the value before being updated, the check cannot be performed. As described above, the conventional software debug device is inconvenient when confirming the update of the value of a variable, and is an obstacle to appropriate debugging.

An object of the present invention is not only when the value of a variable is changed but also when the value of the variable itself is not changed without affecting the execution of a program.
It is an object of the present invention to provide a software debug device which can detect an update of a variable value and check a value before the update.

[0012]

According to the present invention, a first memory means for storing a variable in a program to be debugged and an access status to the first memory means by execution of the program are recorded. Second memory means, latest data storage means for storing the latest value of the variable after execution of the program, old data storage means for storing the value of the variable before execution of the program, and execution of the program And status monitoring means for monitoring an access status to the second memory means by the monitoring means. The status monitoring means obtains an access status from monitoring of the second memory means, and Detecting whether the value of the variable has been updated based on the detected value. Characterized in that it is configured to display the.

As a preferred embodiment of the present invention, the system comprises a debugger section for debugging a program to be debugged, an emulator section for executing the program, and an output device for displaying values of variables in the program. The emulator section includes an emulation memory that stores data and the like in the program, a coverage memory in which an access state to the emulation memory by executing the program is recorded, and an emulation section that executes the program. The debugger unit includes a variable information table that stores variable information of each variable in the program, a latest data storage unit that stores the latest value of each variable, and an old data storage that stores a value of each variable before program execution. Section, a variable value display section that displays the latest value of each variable, and the actual value of each variable. An old variable value display unit for displaying a previous value, a coverage status monitoring unit for monitoring the coverage memory and monitoring an access state to the emulation memory by executing the program, and immediately before executing the program. A coverage memory initialization unit that clears the coverage write status, the coverage status monitoring unit acquires an access status from the address of the coverage memory, and checks whether the value of the variable has been updated, The result is notified to the variable value display unit and the old variable value display unit.

In the present invention, a variable to be debugged, that is, a variable in a source program is:
Allocated in emulation memory. That is, updating the value of a variable by executing the source program is equivalent to writing to the emulation memory to which the variable is assigned. Also, by executing the source program, it is possible to determine what access was made to each address of the emulation memory.
Record in memory. Therefore, by checking the status of the coverage memory corresponding to each address of the emulation memory, it can be determined whether or not the value of the variable has been updated. At this time, the status of interest is a status that becomes valid when writing to the emulation memory is performed, and is called a write status. For example, for a variable with a value of "2",
When the value “2” is substituted, there is no apparent change in the value,
Writing has been performed to the emulation memory, and the value of the variable has been updated. For this reason, the coverage memory corresponding to the address of the emulation memory to which the variable is assigned can know that the value has changed since the write status is valid. "Update to the same value" that could not be detected by comparing the values of variables as in this example
Can also be detected by monitoring the status of the coverage memory.

[0015]

Next, embodiments of the present invention will be described with reference to the drawings. Referring to FIG. 1, a software debug device according to the present invention includes a load module 100 to be debugged in a host machine 1, a debugger unit 120 for debugging, and an emulator for executing a user program to be debugged. Unit 121 and output device 109 for displaying the value of a variable in the source program
And an input device 112. Further, the debugger unit 120 includes a variable information table 103 storing variable information of each variable in the source program from which the load module 100 is generated, and a latest data storage storing the latest value of each variable. Unit 104, an old data storage unit 105 for storing the value of each variable before program execution, and a variable value display unit 107 as a means for displaying the latest value of each variable.
And an old variable value display unit 108 as a means for displaying a value before execution of each variable, and a coverage status monitoring unit 1 for monitoring an access state to a memory by executing a program.
06, and a coverage memory initialization unit 110 that clears the coverage write status immediately before executing the program. The emulator unit 1
21 is realized by an emulation memory 101, a coverage memory 102 in which the state of access to the memory by the execution of the program is recorded, and an emulation unit 122 for executing the program.

The above components will be described in detail. The load module 100 compiles and links a source program created by a user in a high-level language such as C language, and translates the source program into a machine language containing various information for debugging. The variable information table 103
Stores the variable information (symbol information such as variable type and address) of each variable in the source program obtained from the debug information in the load module 100. The latest data storage unit 104 stores the latest value of each variable obtained from the emulation memory 101 based on the address information of each variable stored in the variable information table 103. The old data storage unit 105
Stores the value of a variable before the contents of the latest data storage unit 104 are updated by executing the program.

On the other hand, the emulation memory 101 of the emulator section 121 stores programs (codes in the load module 100) created by the user,
Store the data. Further, the coverage memory 10
Numeral 2 records what access (execution, reading, and writing) has been made to each address of the emulation memory 101 by executing the program. Here, since the emulation memory 101 and the coverage memory 102 are associated one-to-one as shown in FIG. 6A, execution, reading, and execution performed for each address of the emulation memory 101 are performed.
The write access is recorded in the corresponding coverage memory 102. Therefore, by using the write status at the time of executing the program among the access statuses recorded in the coverage memory 102, it is possible to detect whether or not the variable value is updated at the time of executing the program. In this case, when detecting a write access to the emulation memory 101 during one execution of the source program (between the start of execution and the stop of execution), the write status is cleared each time before the execution is started. The coverage memory initialization unit 110 performs this processing.

Further, the output device 109 displays the value of a variable designated by the user in the source program created by the user. The coverage status monitoring unit 106 obtains an access status from an address of the coverage memory 102 corresponding to each address to which each variable displayed on the output device 109 is assigned, and displays the access status on the output device 109. It is checked whether the value of each variable has changed, and the result is displayed on the variable value display unit 107.
To the old variable value display unit 108. The coverage
In the memory 102, the fact that the write status of the address corresponding to each address of the emulation memory 101 to which each variable is assigned is valid means that writing to the address in the emulation memory 101 Has been performed, which means that a value update process such as assignment has been performed on the variable. As a result of investigating the access status acquired from the coverage memory 102, if the write status is valid, the variable value display unit 107 and the variable value display unit 107 indicate that the variable value has changed if the write status is valid. The variable value display unit 108 is notified. Variable value display unit 107
Displays the value of the variable acquired from the latest data storage unit 104 on the output device 109. At this time, when the coverage status monitoring unit 106 notifies that the variable value has been changed, the display color is changed, and when there is no change, the display is performed without changing the display color. The old variable value display unit 108 is notified by the coverage status monitoring unit 106 that a variable value has been changed, and when the mouse pointer serving as the input device 112 is placed on the display portion of the changed value. Only the variable value before execution is acquired from the old data storage unit 105 and displayed on the output device 109.

Next, the operation of the software debug device of FIG. 1 will be described with reference to the flowchart of FIG. The flowchart in FIG. 2A is a process when the user operates to display a variable whose value is to be monitored on the output device 109 among variables existing in the source program. The flowchart of FIG. 2B is a process performed when the user performs an operation of executing the source program. The variables displayed on the output device 109 by the process of the flowchart of FIG. This is the process that is performed. First, when the user attempts to monitor the value of a specific variable among the variables existing in the source program, the user performs an operation of displaying the variable whose value is to be monitored on the output device 109 (step A1). Then, the software debugging apparatus of the present invention acquires the information of the variable specified in step A1 (symbol information such as type and address) from the debugging information in the load module 100,
It is stored in the variable information table 103 (step A2).
Further, based on the address information of each variable stored in the variable information table 103, the emulation memory 10
Since it is possible to know which address in 1 the variable is assigned to, the latest value of each variable is read from the emulation memory 101 based on the address value and stored in the latest data storage unit 104 ( Step A
3). Then, the variable value display unit 107 outputs the value of each variable stored in the latest data storage unit 104 to the output device 109 (Step A4).

When the execution of the source program is prompted by the user, first, before the execution of the source program is started, the coverage memory initialization unit 11
0 initializes the write status of the coverage memory 102 (step A5). Thereafter, execution of the program is started (step A6). Whether a command to stop the program execution has been received from the user during the execution of the program, a command to execute only one line (hereinafter, one-step execution), a position at which the program execution is to be stopped has been previously specified by the user, and the like. The execution of the program is stopped by the stop factor (step A7). After the execution of the program is stopped, first, the contents of the latest data storage unit 104 (values of the variables before execution) are saved in the old data storage unit 105 (step A8). After step A7, the latest value of each variable is obtained from the emulation memory 101 and stored in the latest data storage unit 104 (step A).
9). Next, the coverage status monitoring unit 106
Obtain the access status of the address of the coverage memory 102 to which the variable is assigned (step A)
10), it is checked whether the write status is valid (step A11). If the write status is valid, the latest value is displayed in a different display color (step A12 & step A4). If not valid, the value is displayed without changing the display color (step A4). Further, it checks where the position of the mouse pointer as the input device 112 is (step A13). If the mouse pointer is positioned over the changed value, the value before executing the program is displayed (step A14). If the mouse pointer is not positioned over the changed value, the process continues (step A15).

A specific example of the above operation will be described using the source program of FIG. 3 as an example. In the source program of FIG. 3, variables str, p, count, and zero exist in the program. These are assigned to the respective addresses 0x100, 0x10A, 0x10E, 0x112 of the emulation memory as shown in the example of the variable information table in FIG. Among these four variables, especially the variable coun
Focusing on t and zero, the operation in FIG. First, consider the execution of the tenth line in the source program of FIG. At this time, the variable just before executing the 10th line
Assume that the value of count is "3". In the old data storage unit 105, the value of the variable count immediately before the execution of the tenth line is “3”.
Is stored. When the 10th line is executed, the process of incrementing the value of the variable p by “1” (incrementing it by one) is performed, so that the substitution process for the variable count is not performed. That is, writing is not performed on the address 0x10E of the emulation memory 101. Therefore, the write status of the coverage memory 102 corresponding to the address 0x10E remains invalid. Therefore, the variable value display unit 107 displays the value “3” obtained from the latest data storage unit 104 on the output device 109.

Next, looking at the execution of the next eleventh line, the value of the variable count immediately before the execution of the eleventh line is “3”, and the old data storage unit 105 executes the eleventh line. The value “3” of the variable “count” immediately before is stored. 1
When the first line is executed, a process of incrementing the value of the variable “count” by “1” is performed, so that an assignment process is performed on the variable “count”. That is, writing is performed to the address 0x10E of the emulation memory 101.
Therefore, the write status of the coverage memory 102 corresponding to the address 0x10E becomes valid. For this reason, the variable value display unit 107 displays the value “4” obtained from the latest data storage unit 104 on the output device 109 with a different display color. When the mouse pointer is placed on the value “4” displayed with the display color changed, the old variable value display unit 108 displays the variable value “3” before execution from the old data storage unit 105. The acquired information is displayed on the output device 109.

Next, regarding the variable zero in the execution of the thirteenth line, the value of the variable zero immediately before the execution of the thirteenth line is “0”, and the old data storage unit 105 executes the execution of the thirteenth line. The value “0” of the variable zero immediately before is stored. 1
When the third line is executed, a process of substituting “0” for the variable zero is performed.
Writing is performed to address 1x112. Therefore, the write status of the coverage memory 102 corresponding to the address 0x112 becomes valid. For this reason,
The variable value display unit 107 displays the value “0” obtained from the latest data storage unit 104 on the output device 109 by changing the display color. Variable value "0" displayed with different display color
When the mouse pointer is placed on the variable, the old variable value display unit 108 acquires the value “0” of the variable before execution from the old data storage unit 105 and displays it on the output device 109.

The above operation will be described in detail. here,
For the source program of FIG. 3, the variable information table of FIG. 4, an example of the output device of FIGS. 5 (a) to 5 (c), and the emulation memory 101 of FIGS. 6 (a) to 6 (c). From the relationship of the coverage memory 102, the variable co
Using unt and zero as examples, the operation in the case where there is no change in the value due to the execution of the program and the case where the value does not change will be described. First, in the source program of FIG. 3, it is assumed that when the execution is performed up to the ninth line, the user performs a process of displaying the variable count on the output device 109. Also, assume that the value of the variable count at this point is “3”. When the user performs a process of displaying the variable count on the output device 109, the debugger unit 120 first registers the symbol information of the variable count acquired from the debug information in the load module 100 in the variable information table 103. Next, from the emulation memory 101, the address 0x10
The value “3” of E (address stored in the variable information table 103) is read and stored in the latest data storage unit 104. The variable value display unit 107 is the latest data storage unit 1
The value “3” of the variable “count” stored in 04 is displayed on the output device 109 without changing the display color.

Here, it is assumed that the user performs an operation of executing the tenth line to stop the program. First, the coverage memory initialization unit 110 executes the operation of the coverage memory 102.
Initialize the write status of. After the execution is completed, the value “3” before program execution is saved from the latest data storage unit 104 to the old data storage unit 105. After saving the value before the program is executed, the value “3” at the address 0x10E is read from the emulation memory 101 and stored in the latest data storage unit 104. Next, the coverage status monitoring unit 106 acquires the access status of the coverage memory 102 corresponding to the address 0x10E of the emulation memory 101, and checks whether the write status is valid. In this case, the coverage memory 1
02 is as shown in FIG. 6A. Since the write status is not valid at the address to which the variable count is assigned, the value is displayed in the variable value display unit 107 and the old variable value display unit 108. Tell that there were no changes.
The variable value display unit 107 acquires the value “3” from the latest data storage unit 104, and displays the value on the output device 109 without changing the display color as shown in FIG.

Next, it is assumed that the user performs an operation of executing the eleventh line to stop the program. First, the coverage memory initialization unit 110 initializes the write status of the coverage memory 102. After the execution is completed, the value “3” before the execution of the program is saved from the latest data storage unit 104 to the old data storage unit 105. After saving the value before executing the program, the value “4” at the address 0x10E is read from the emulation memory 101 and stored in the latest data storage unit 104. Next, the coverage status monitoring unit 106 acquires the access status of the coverage memory 102 corresponding to the address 0x10E of the emulation memory 101, and checks whether the write status is valid. In this case, the coverage memory 10
2 is as shown in FIG. 6B. Since the write status is valid at the address to which the variable count is assigned, the value is displayed in the variable value display unit 107 and the old variable value display unit 108. Tell them that there has been a change. The variable value display unit 107 reads the value “4” from the latest data storage unit 104.
Is acquired, and the value is displayed on the output device 109 by changing the display color. When the mouse pointer is placed on the variable value “4” (the value after execution), the old variable value display unit 108 acquires the value “3” (the value before execution) from the old data storage unit 105, FIG.
The value is displayed on the output device 109 as shown in FIG.

Here, the user sets the variable zero in the output device 10.
It is assumed that a process for displaying the image on the screen 9 has been performed. The value of the variable zero at the time when the execution is completed up to the eleventh line is “0”. At this time, the debugger unit 120 first registers the symbol information of the variable zero acquired from the debug information in the load module 100 in the variable information table 103. Further, the address 0x11 is read from the emulation memory 101.
2 The value “0” of (the address stored in the variable information table 103) is read and stored in the latest data storage unit 104. The variable value display unit 107 is the latest data storage unit 1
The value “0” of the variable zero stored in 04 is displayed on the output device 109 without changing the display color.

Further, it is assumed that the user performs an operation to stop the program by executing up to the thirteenth line. First, the coverage memory initialization unit 110 determines whether the coverage memory 1
02 is initialized. After the execution ends,
The value “0” before executing the program is saved from the latest data storage unit 104 to the old data storage unit 105. After saving the value before executing the program, the emulation memory 101
The value “0” at the address 0x112 is read out from the storage unit 104 and stored in the latest data storage unit 104. Next, the coverage status monitoring unit 106 checks the coverage memory 10 corresponding to the address 0x112 of the emulation memory 101.
2 is obtained, and it is checked whether the write status is valid. In this case, the coverage memory 102 is as shown in FIG.
Since the write status is valid for the address to which is assigned, the variable value display unit 107 and the old variable value display unit 108 are notified that the value has been changed. The variable value display unit 107 acquires the value “0” (the value after execution) from the latest data storage unit 104, and changes the display color to display the value on the output device 109. When the mouse pointer is placed over the variable value 0, the old variable value display unit 108 acquires “0” (the value before execution) from the old data storage unit 105, and
A pop-up is displayed as shown in FIG.

[0029]

As described above, according to the present invention, the status monitoring means monitors the second memory means in which the access status to the first memory means for storing the variables in the program is recorded. Detect if the value of a variable has been updated based on the access status obtained,
Based on the detection, the latest variables after the execution of the program and the old variables before the execution are displayed, so that the following effects can be obtained. The first effect is that the value of the variable is changed to a different value by executing the program, for example, that the variable value is changed not only from “0” to “1” but also to the same value, For example, "0" → "0"
The change of the variable value to can be detected without affecting the execution of the program. The reason is that a change to the same value, which could not be detected by the comparison of the old and new data, is detected by monitoring the write status in the second memory means. Instead, a change to the same value can be detected. A second effect is that, for a variable whose value has been changed by execution of a program, the value before execution of the program can be displayed on a window displaying the latest value. The reason is that a function of retaining old data and displaying old data is provided, and a variable whose value has been changed can be specified by the write status recorded in the second memory means.

[Brief description of the drawings]

FIG. 1 is a block diagram of a debugging device according to the present invention.

FIG. 2 is a flowchart for explaining the operation of the present invention.

FIG. 3 is an example of a source program for explaining the operation of the debugging device.

FIG. 4 is a diagram showing an example of a variable information table of the source program of FIG. 3;

FIG. 5 is a diagram illustrating a display example of an output device.

FIG. 6 is a diagram showing a correspondence between an emulation memory and a coverage memory;

FIG. 7 is a block diagram illustrating an example of a conventional debugging device.

FIG. 8 is a flowchart for explaining the operation of the conventional debugging device.

[Explanation of symbols]

 1 Host Machine 100 Load Module 101 Emulation Memory 102 Coverage Memory 103 Variable Information Table 104 Latest Data Storage 105 Old Data Storage 106 Old Variable Value Display 107 Variable Value Display 108 Coverage Status Monitor 109 Output Device 110 Coverage memory initialization unit 111 Data comparison unit 112 Input device 120 Debugger unit 121 Emulator unit 122 Emulation unit

Claims (4)

[Claims] A first memory for storing a variable in a program to be debugged; a second memory for recording an access state to the first memory by execution of the program; To the latest data storage means for storing the latest value of the variable after execution of the program, to the old data storage means for storing the value of the variable before execution of the program, and to the second memory means by execution of the program Status monitoring means for monitoring an access status of the second memory means, wherein the status monitoring means obtains an access status from monitoring of the second memory means, and updates the value of the variable based on the access status. Configuration to detect whether the data has been deleted and to display the values of the variables in the latest data storage means and the old data storage means based on the detection. A software debug device characterized by the following. A debugger section for debugging a program to be debugged; an emulator section for executing the program; and an output device for displaying a value of a variable in the program. An emulation memory for storing data and the like in the program; and an emulation memory for executing the program.
A coverage memory in which an access state to the memory is recorded; and an emulation unit that executes the program. The debugger unit includes a variable information table that stores variable information of each variable in the program, and a latest information of each variable. The latest data storage unit that stores the value of each variable, the old data storage unit that stores the value of each variable before the program is executed, the variable value display unit that displays the latest value of each variable, and the value before execution of each variable An old variable value display unit for displaying the program, and a coverage unit for monitoring the coverage memory to monitor an access state to the emulation memory by executing the program.
A status monitor and a coverage monitor that clears the coverage write status immediately before executing the program
A memory initialization unit, wherein the coverage status monitoring unit acquires an access status from an address of the coverage memory, checks whether the value of the variable has been updated, and displays the result with the variable value display unit. A software debugging device characterized in that a notification is provided to an old variable value display section. 3. The latest data storage unit stores the latest value of each variable obtained from the emulation memory based on the address information of each variable stored in the variable information table, The software debug device according to claim 2, wherein the data storage unit stores a value of a variable before the content of the latest data storage unit is updated by executing a program. 4. The variable value display unit outputs the value of the variable obtained from the latest data storage unit to the output device, and when the coverage status monitoring unit notifies the update of the variable, the obtained variable value is displayed. Change the display color of, if there is no update, perform display without changing the display color, and the old variable value display unit outputs the value of the variable obtained from the old data storage unit to the output device, 3. The acquired variable is displayed only when the mouse pointer is placed on the display portion of the changed value when the update of the variable is notified from the coverage status monitoring unit. 4. The software debugging device according to 3.