JP2002014843A - Program execution trace system - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a program execution trace system for instantaneously presenting trace information related with a data change history when any failure is generated due to memory destruction. SOLUTION: This system is provided with a table to be checked in which the address of certain data in a program to be debugged and an exceptional stop condition for stopping the program to be debugged when any writing protection exception is generated for the data, a writing protection attribute setting part for setting information related with the address to be checked and the exceptional stop condition in the table to be checked, and for operating a memory control unit to inhibit writing in a page including the data, and a writing protection exception handler to be started at the time of receiving the notification of the writing protection exception for the address to be checked for stopping the program to be debugged, and for presenting trace information until that time when the exceptional stop condition is fulfilled.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a computer system having a protection mechanism that manages a main memory in fixed length units called pages and enables access control in page units. The present invention relates to a program execution tracing method that, when a program execution failure occurs, cooperates with a debugger to retain a change history of data that triggered the failure.

[0002]

2. Description of the Related Art When debugging a program, it is required to confirm the execution status of the program when the content of data located at a specific address on a main memory is changed to a specific value. There is. Conventional debugging devices are designed to stop execution of a program without delay at the moment when the value of certain data is changed, using only software without adding dedicated hardware.
Some have fulfilled such demands. For example, the debug device disclosed in Japanese Patent Application Laid-Open No. 8-30485 corresponds to this.

Next, the operation will be described. FIG.
FIG. 9 is a diagram illustrating a conventional debugging device. When debugging the debug target program 1, first, the operator operates the console 7 to set a break condition in the debugger body 6. The break condition set here is a condition that a break occurs when the content of the inspection target address 4 in the memory 3 reaches a specific value. Break condition setting means 8 notified of a break condition from debugger body 6
Notifies the write protection exception handler 5 of the break condition, and operates the memory management unit 2 to set the write protection attribute for the page including the inspection target address 4. After that, the debugger body 6 starts the debug target program 1. When the debug target program 1 writes to the page including the inspection target address 4, a write protection exception occurs in the memory management unit 2, and the write protection exception handler 5 is activated. In the write protection exception handler 5, it is checked whether or not the address that caused the write protection exception in the page including the check target address 4 matches the check target address 4 set in the break condition. Since the setting of the write protection exception is performed on a page basis, an exception occurs when an attempt is made to change (write) data at an arbitrary address in a write-protected page. That is,
Since a write protection exception also occurs for a neighboring address that does not match the inspection target address, it is checked whether the address that caused the write protection exception matches the inspection target address set in the break condition. If they match, it is further checked whether the changed value meets the break condition. If the break condition is met, the debugger body 6 is called. As a result, the operator can inspect the state of the debug target program 1 via the console 7. In the case where the inspection target address 4 and the break condition do not match in the course of each of the above inspections, and when the execution of the debug target program 1 is continued,
The setting of the write prohibition attribute is temporarily released, and after writing to the memory address, the program returns to the debug target program 1.

As described above, in the conventional debugging device,
Triggered by the occurrence of the write protection exception by the memory management unit 2, the debug target program 1 can be stopped without delay at the time of writing data to the specified memory address only by software.

[0005]

In a fault due to memory corruption, the location of the code that damages the data in memory is often independent of the location where the failure occurs by using that data. May be far away. Therefore, debugging work for this type of failure is difficult. In the conventional debugging device, the debug target program stops every time a break condition is met, and each time the operator checks the state of the debug target program, and performs an operation to continue the program execution if necessary. When the program execution is continued, since the data change history is not retained, the operator records the change history on paper as necessary, and examines a point at which it is determined that unauthorized data writing has been performed later. It takes time. Also, in specifying break conditions, it is difficult to specify an appropriate break condition from the beginning because data values determined to be invalid are individually different, and it is necessary to change the break condition and re-execute from the beginning. In some cases. As described above, there is a problem that the efficiency of the actual debugging operation is low.

SUMMARY OF THE INVENTION The present invention has been made to solve the above problems, and traces data changes in a memory, and immediately traces a data change history when a failure occurs due to memory corruption. An object of the present invention is to improve debugging efficiency by presenting information.

[0007]

A program execution trace method according to the present invention designates certain data in a program to be debugged as data to be inspected, designates an exceptional stop condition for stopping the program to be debugged, and specifies the data. And write-protect the page containing the data, store the trace information for that data in response to the occurrence of a write protection exception for that data, and stop the program to be debugged when the generated write protection exception matches the exception stop condition. The present invention is characterized in that trace information up to that point is presented.

The program execution trace method according to the present invention includes: (a) a debugger body for an operator to perform a debugging operation; (b) an instruction execution unit for executing a debug target program; and (c) instructions and data of the debug target program. (D) The memory unit has a protection mechanism that enables access control of the memory unit in page units. When a write occurs to data in a page for which write protection is set, a write protection exception is generated. Memory management unit for notification (e) Address of certain data in the program to be debugged (this is called an address to be inspected) and an exception stop for stopping the program to be debugged when a write protection exception occurs for the data Inspection target table that holds conditions (f) Debugging target program A write protection attribute setting unit that sets information on the address to be inspected and the exceptional stop condition in the table to be inspected and operates the memory management unit so as to prohibit writing to the page containing the data. Is activated upon receiving a write protection exception notification for the address to be inspected. If the exception stop condition is satisfied, the debug target program is stopped and the trace information up to that point is presented. If the exception stop condition is not satisfied, a trace process is requested. Write protection exception handler (h) A trace body that stores trace information when a write occurs to an inspection target address based on a trace processing request of the write protection exception handler.

The program execution trace method according to the present invention comprises: (i) a trace buffer for holding trace information in a trace body; and (j) trace information management for writing trace information to the trace buffer in the trace body. And (k) a trace buffer control unit for reading trace information from the trace buffer within the trace body.

[0010] The trace buffer of the program execution trace method according to the present invention stores at least a value to be changed, an instruction execution address when an exception occurs, and process information that caused the exception as trace information. Features.

The trace body included in the program execution trace method according to the present invention further holds a trace flag for specifying whether to perform a subtrace for an address in the vicinity of write-protected data. The sub-trace is performed on an address in the vicinity of the inspection target address.

The inspection target table included in the program execution trace method according to the present invention has a second exception stop condition that designates a process as one of the conditions for stopping the debug target program, and the write-protection exception handler uses the second exception stop condition. The method is characterized in that the debug target program is stopped when a write protection exception from the process occurs using the exception stop condition of (2).

In the program execution trace method according to the present invention, the inspection target table has a trace selection flag for each inspection target address, and the write protection exception handler executes a trace for each inspection target address using the trace selection flag. It is characterized by selecting whether or not to perform.

[0014] In the program execution trace method according to the present invention, the inspection target table includes a trace target process condition in which a certain process or a process satisfying a certain execution level condition is designated as a trace target process.
The trace body is characterized in that the trace is executed only when a designated process or a process that satisfies the designated execution level condition writes to the inspection target address using the trace target process condition.

The program execution trace method according to the present invention is characterized in that a trace body is arranged in a debugger body.

[0016]

DESCRIPTION OF THE PREFERRED EMBODIMENTS Embodiment 1 FIG. 1 is a block diagram showing a configuration of the first embodiment. In FIG. 1, 1
0 is a debugger main body operated by an operator, 11 is a program to be debugged, 12 is an instruction execution unit, 13 is a memory management unit which manages a memory unit 14 in a fixed length called a page, and can implement write protection in page units. , 14 is a memory unit, 15 is an inspection target address in the memory unit 14, and 16 is a memory management unit 13 which is activated via a command execution unit 12 when a write command to a page to which a write protection attribute is set is executed. A write-protection exception handler 17 to be written; a write-protection attribute setting unit 17 for setting the memory management unit 13 to prohibit writing to the data of the program 11 to be debugged; Inspection target table holding information, 1 Trace body for tracing when a write occurs to the data that is the write-protected inside the inspection object table 18, 20 is the trace buffer that stores the trace information, 21 inspection target address 1
A trace flag for designating whether or not to perform sub-trace for a neighboring address other than 5; 22, a trace information management unit for writing trace information based on an instruction from the write protection exception handler 16; Is a trace buffer control unit for reading trace information based on.

FIG. 2 is a diagram showing a configuration of the inspection target table 18 according to the first embodiment. In FIG. 2, 30
Is a data address of data to be inspected, 31 is a data size, 32 is an exceptional stop condition indicating a condition to stop when the address to be inspected 15 has a specific value, and 33 is an entry to be inspected composed of the above three sets. is there. The inspection target table 18 includes a plurality of inspection target entries 33. In practice, when checking whether the address where the write protection exception has occurred matches the check target address, the data address 30 is keyed so that the search for the check target entry 33 can be performed at high speed or within a predictable time. And a data structure such as a hash table or a binary tree.

FIG. 3 is a diagram showing a configuration of the trace buffer 20 (and sub-trace buffer) according to the first embodiment. In FIG. 3, reference numeral 40 denotes a data address to be inspected, 41 denotes a changed value when an attempt is made to write to the data address 40 to be inspected, and 42 denotes an instruction execution address when an attempt is made to write to the data address 40 to be inspected. , 43 are the execution process IDs of the processes that attempted to write to the data address 40 to be inspected, and 44 is a trace buffer entry composed of the four sets. The trace buffer 20 is composed of a plurality of trace buffer entries 44 and maintains the order in which writing to the data address 40 to be inspected has occurred. The sub-trace buffer stores sub-trace information to be described later. The configuration of the sub trace buffer is the same as that of the trace buffer shown in FIG.

FIG. 4 is a diagram showing a configuration of the trace flag 21 according to the first embodiment. In FIG. 4, reference numeral 50 denotes a sub-trace bit for determining whether to execute a sub-trace described later.

Next, the operation will be described. First, the operator specifies the debug target program 11 on the debugger body 10. Then, the debug target program 11
The address of certain data in the address is set as the inspection target address 15, and a condition for stopping when the content reaches a specific value is indicated. At this time, the operator sets the inspection target address 1
5 together with a specific exception stop condition. The write protection attribute setting unit 17 holds the inspection target address 15 (data address 30), data type (data size 31), and exception stop condition 32 passed from the debugger body 10 in the inspection target table 18 and a memory management unit. 13 to set the write-protection attribute for the page including the inspection target address 15. Note that the operator can set a plurality of inspection target addresses 15 (data addresses 30) at the same time. Then, the debugger body 1
0 activates the debug target program 11. During the execution of the debug target program 11, the check target address 15
, The write protection exception handler 16 is activated.

FIG. 5 is a diagram showing a flowchart of the write protection exception handler 16. The processing of the write protection exception handler 16 will be described with reference to FIG. First, in step S1, the check target table 18 is used to check whether the address where the write protection exception has occurred is the check target address.
Search for. Normally, the size of the page set with the write-protected attribute is larger than the address 15 to be inspected, so that the data address 30 (that is,
It is checked whether it matches the inspection target address 15 based on the (head address) and the data size 31. If they do not match, the process proceeds to step S2, where the trace main body 19 is called to execute a trace (referred to as a subtrace) for an address other than the inspection target address in the page in which the write-protection attribute is set. The trace information management unit 22 in the trace body 19 recognizes and distinguishes the trace for the inspection target address 15 and the sub-trace for the address other than the inspection target address in the page, and stores the trace buffer entry 44 in the respective trace buffer 20 and sub-trace buffer. Is additionally recorded. After executing the trace, the process proceeds to step S9, where writing is performed at a desired address, and the process returns to the debug target program 11. On the other hand, when the address matches the inspection target address 15, the process proceeds to step S3, and the trace body 19 is called. The trace information management unit 22 in the trace body 19 additionally records a trace buffer entry 44 in the trace buffer 20 as a trace for the inspection target address 15. After executing the trace, the process proceeds to step S4, and the inspection target address 15
A check is made to see if the change value for satisfies the exception stop condition 32. If the condition is not satisfied, the process proceeds to step S9, where writing to the inspection target address 15 is performed, and the process returns to the debug target program 11. If the condition is satisfied, step S
Proceed to step 5, and call the debugger body 10. When the debugger body 10 is called, the state of the debug target program 11 can be checked. In step S6, the debugger 10 calls the trace body 19. Trace buffer control unit 23 in trace body 19
Reads the trace information on the current inspection target address 15 from the trace buffer 20. Debugger body 1
0 indicates that the acquired trace information is appropriately processed and displayed. If the execution of the debug target program 11 is to be stopped, the process proceeds to step S8, and the process ends without writing to the test target address 15. If the execution is to be continued, the process proceeds to step S9, where writing is performed on the inspection target address 15, and
The program returns to the debug target program 11.

FIG. 6 is a flowchart showing the processing of the trace information management section 22 in the trace main body 19 in steps S2 and S3. The processing of the trace information management unit 22 in the trace main body 19 will be described with reference to FIG. The write protection exception handler 16 writes the quad data to be written to the trace buffer entry 44 and identification information indicating whether or not the exception address matches the check target address 15 or not.
Pass to. When the trace body 19 is called from the step S2, identification information indicating that the exceptional address does not match the inspection target address 15 is set. Also,
When the trace body 19 is called from the step S3, identification information indicating that the exceptional address matches the inspection target address 15 is set. Step S20
Then, it is determined whether or not the exceptional address matches the check target address 15 with reference to the identification information. If they do not match, the process proceeds to step S21, and it is determined with reference to the trace flag 21 whether sub-trace is to be executed with the current setting. If no subtrace is to be executed, return immediately. When the sub-trace is to be executed, the process proceeds to step S22, and the trace buffer entry 44 including the above-mentioned quadruple data is written in the sub-trace buffer. In step S23, the process returns after updating the management information of the sub trace buffer. On the other hand, as a result of referring to the identification information, if the exceptional address matches the inspection target address 15, the process proceeds to step S24, and the trace buffer entry 44 including the above-described quad data is written in the trace buffer 20. In step S25, the process returns after updating the management information of the trace buffer.

FIG. 7 is a flowchart showing the processing of the trace buffer control unit 23 in the trace main body 19 in the step S6. The processing of the trace buffer control unit 23 in the trace main body 19 will be described with reference to FIG. The exception address matches the inspection target address 15,
Further, when the changed value matches the exception stop condition 32, the debugger main body 10 specifies the current inspection target address 15 in step S6 and
3 and issues a trace information read request. In step S6, a trace address may be read from the sub-trace buffer by specifying a neighboring address other than the inspection target address 15. In step S30, the trace buffer to be read is switched. In step S31, it is determined whether or not the read request from the debugger body 10 is a continuation from the previous time. If the continuation is not continued, the process proceeds to step S32, in which a write pointer pointing to the trace buffer entry 44 that has been written last is obtained, and the trace buffer entry 4 matching the passed inspection target address 15 is obtained.
4 is returned to the debugger body 10. On the other hand, if the request for reading the next entry is continuously issued from the debugger main body 10, the process proceeds to step S33, where the next entry is searched starting from the current search pointer, and the trace information is transmitted to the debugger main body 10 at the time of finding. return it.

As described above, tracing is performed upon occurrence of a write protection exception for data for which the write protection attribute is set, and the data change history is retained. The change history up to that time can be presented. By presenting this change history, it is possible to know which process wrote what value in which execution place, and it is easy to track illegal data writing, and to assist in the operation analysis of programs related to data access It is also possible to
Debugging efficiency can be improved. Furthermore, it is generally said that there is locality in data access, and it is possible to simultaneously present a change history for neighboring addresses that do not match the inspection target address, thereby improving debugging efficiency. .

Embodiment 2 In the first embodiment,
Although the condition relating to the change value is specified as the exception stop condition 32 in the inspection target table 18, the process information which caused the exception is set as the second exception stop condition, and the condition relating to the change value is set as the second exception stop condition. An embodiment in which the debugger body 10 is called in response to an access from a designated process will be described. FIG. 8 is a diagram showing a configuration of the inspection target table 18 according to the second embodiment in which FIG. 2 is modified. In FIG. 8, reference numeral 34 denotes a condition for designating a process that has caused an exception, and is an exception stop condition 2 (also referred to as a second exception stop condition) for calling the debugger body 10 upon access from the process. .

First, the operator specifies a program 11 to be debugged on the debugger body 10. Then, an address of a certain data in the debug target program 11 is set as a check target address 15, and its content becomes a specific value,
In addition, a condition for stopping when a specific process writes to the inspection target address 15 is indicated. At this time, the operator specifies specific first exceptional stop conditions 32 and second exceptional stop conditions 34 together with the inspection target address 15. After that, the debugger body 10 starts the debug target program 11. When writing to the page including the inspection target address occurs during execution of the debug target program 11, the write protection exception handler 16 is activated.

FIG. 5 is a diagram showing a flowchart of the write protection exception handler 16 described in the first embodiment.
The characteristic processing of the write protection exception handler 16 according to the second embodiment will be described with reference to FIG. In the case of the first embodiment in step S4, it is checked whether or not the changed value for the inspection target address 15 satisfies the exception stop condition 32.
On the other hand, in the case of the second embodiment, when the exception stop condition 32 relating to the change value is satisfied and the second exception stop condition 34 relating to the process that caused the exception is satisfied, the process proceeds to step S5, and the debugger main body 10 is reset. call. If at least one of the two exception stop conditions is not satisfied, the process proceeds to step S 9, where the write to the inspection target address 15 is performed, and the process returns to the debug target program 11.

As described above, by providing the second exception stop condition 34 in the inspection target table 18, the debugger can be triggered by the access from the designated process that has caused the write protection exception, together with the change value for the inspection target address 15. Since the main unit 10 is called, the debug target program 11 can be
Can be stopped.

Embodiment 3 In Embodiment 2 described above,
All data writing specified as the inspection target address 15 is traced. Next, a new trace selection flag for each inspection target address 15 is provided in the inspection target table 18 so that it is possible to select whether to individually perform tracing. An embodiment of the case will be described. FIG. 9 is a diagram illustrating a configuration of the inspection target table 18 according to the third embodiment in which FIG. 2 is modified. In FIG. 9, reference numeral 35 denotes a trace selection flag indicating whether or not tracing is performed for each inspection target address 15.

FIG. 10 is a diagram showing a flowchart of the trace information management section 22 in the third embodiment, which is a modification of FIG. First, the operator specifies some of the inspection target addresses 15 already set and instructs not to perform tracing. The debugger body 10 checks the inspection target table 1 corresponding to the specified inspection target address 15.
The trace selection flag 35 in 8 is set so that tracing is not performed. Thereafter, during execution of the debug target program 11, writing to a page including the inspection target address occurs, the write protection exception handler 16 is activated, and if the exception address matches the inspection target address 15, the trace information management unit 22 Call. Next, a characteristic process of the trace information management unit 22 according to the third embodiment will be described with reference to FIG. In step S20, by checking the identification information passed from the write protection exception handler 16, it is checked whether the exception address is the check target address 15. If the address is the inspection target address 15, the process proceeds to step S26, where the trace selection flag 35 in the inspection target table 18 is set.
Check the setting status of. If the setting has been made to execute the trace, the process proceeds to step S24, and writing to the trace buffer is performed. If it is set not to execute the trace, the process immediately returns to the write protection exception handler 16.

As described above, the provision of the trace selection flag 35 in the inspection target table 18 makes it possible to select whether or not to execute tracing for each inspection target address 15, so that trace information can be reduced and trace processing can be performed. Can be reduced. It should be noted that the setting of the trace selection flag 35 may only be explicitly set to execute tracing, and if no setting has been made, tracing may not be executed.
Alternatively, on the contrary, only the setting of not executing the trace may be explicitly performed, and if the setting has not been made, it may be considered that the trace is executed.

Embodiment 4 FIG. In Embodiment 3 described above,
By providing a trace selection flag 35 in the inspection target table 18, it is possible to select whether or not to execute a trace for each inspection target address 15. Next, a new trace target process condition is provided in the inspection target table 18. In this embodiment, a trace is executed only when a specified process or a process that satisfies a specified execution level condition writes to the inspection target address 15. FIG. 11 is a diagram illustrating a configuration of the inspection target table 18 according to the fourth embodiment in which FIG. 2 is modified. In FIG. 11, reference numeral 36 denotes a trace target process condition indicating a condition of a process to be traced among data write processes for each inspection target address 15.

FIG. 12 is a diagram showing a flowchart of the trace information management unit 22 in the fourth embodiment, which is a modification of FIG. First, when specifying the inspection target address 15, the operator specifies the trace target process condition 36 together with the specific exception stop condition 32. The trace target process condition 36 specified here includes the process itself in the debug target program 11, the execution level equal to or higher than the process in the debug target program 11, and the like. Note that it is also possible to specify a plurality of conditions such as a process and a kernel in the debug target program 11 and execute the trace only when all the conditions are satisfied. The debugger body 10 sets a trace target process condition 36 in the test target table 18 corresponding to the specified test target address 15. Thereafter, during execution of the debug target program 11, writing to a page including the inspection target address occurs, the write protection exception handler 16 is activated, and if the exception address matches the inspection target address 15, the trace information management unit 22 Call. Next, a characteristic process of the trace information management unit 22 according to the fourth embodiment will be described with reference to FIG. Step S20
In step (1), the identification information passed from the write-protection exception handler 16 is checked to determine whether the exception address is the check target address 15. If the address is the inspection target address 15, the process proceeds to step S27, and it is checked whether or not the process that has caused the write protection exception matches the trace target process condition 36. If the condition is met, the process proceeds to step S24, where writing to the trace buffer is performed. If the condition is not met, the process immediately returns to the write protection exception handler 16.

As described above, by setting the trace target process condition 36 in the test target table 18, the process to be accessed can be separated for each test target address 15. It is possible to quickly find an execution position, reduce trace information, and reduce the overhead of trace processing.

Embodiment 5 FIG. Embodiments 3 and 4 above
Then, the inspection target address 15 is stored in the inspection target table 18.
By providing a trace selection flag 35 and a trace target process condition 36 for determining whether or not tracing can be performed for each trace, the trace target can be more finely controlled. 10 shows an embodiment in the case of arranging in the apparatus 10.

FIG. 13 is a block diagram showing the structure of the fifth embodiment. In FIG. 13, individual components are shown in FIG.
Is the same as the block diagram showing the configuration of the first embodiment shown in FIG. However, the trace main body 19 including the trace buffer 20, the trace flag 21, the trace information management unit 22, and the trace buffer control unit 23 is disposed in the debugger main body 10. Each process in the trace body 19 described with reference to FIGS. 6, 7, 10 and 12 is as follows.
Since there is no dependency on the external function unit in executing those processes, the trace body 19 itself can be arranged in the debugger body 10. In the flow chart of the write protection exception handler 16 described with reference to FIG. 5, the trace main body 19 is called to execute the trace in steps S2 and S3.
In the case of the fifth embodiment, a request for processing is sent to the trace information management unit 22 via the debugger body 10. Also,
In step S6, the trace main body 19 is called based on an instruction from the debugger main body 10 to read out the trace information. In the fifth embodiment, the debugger main body 10 and its internal part are independent of the existing system software. The trace information is read out or displayed in a format with the trace buffer control unit 23.

As described above, by arranging the trace body 19 in the debugger body 10, the independence from the existing system software can be enhanced, and the trace body 19 can be easily removed in the normal operation mode after the end of debugging. Becomes possible.

[0038]

As described above, according to the present invention, data change in the memory is traced, and when a failure occurs due to memory destruction, trace information relating to the data change history is immediately presented. Improve debugging efficiency.

Further, according to the present invention, the trace is performed upon occurrence of a write protection exception to the data for which the write protection attribute is set, and the change history of the data is retained. When it is done, the change history up to that point can be presented immediately. In addition, by presenting this change history, it is possible to know what process wrote what value at which execution location, and it is easy to trace illegal data writing, and to analyze the operation of a program related to data access. Can be supported, and the debugging efficiency can be improved. Further, it is generally said that there is locality in data access, and it is possible to simultaneously present a change history for neighboring addresses that do not match the inspection target address, thereby improving debugging efficiency. Can be.

Further, since the processing of the trace main body can be performed in the trace main body, each processing in the trace main body 19 does not depend on an external function unit in executing the processing.

Further, since the trace information includes the instruction execution address when an exception occurs and the process information that caused the exception, it is possible to easily know the instruction of the process whose data has been changed.

Further, since the sub trace is performed,
Debugging efficiency can be improved.

Further, since the debugger body 10 is called upon access from a designated process that has generated a write protection exception, the debug target program 11 can be stopped at more accurate data write timing.

Further, by providing a trace selection flag 35 in the inspection target table 18, it is possible to select whether or not to execute the trace for each inspection target address 15, so that the trace information is reduced and the overhead of the trace processing is reduced. It becomes possible to reduce.

Further, since the process to be accessed for each inspection target address 15 can be separated by providing the trace target process condition 36 in the inspection target table 18, the identification and execution location of the process to perform the illegal writing can be determined. It is possible to find out quickly, and it is possible to reduce the trace information and the overhead of the trace processing.

The trace body 19 is connected to the debugger body 1
By arranging it in 0, the independence from the existing system software can be enhanced, and in the normal operation mode after the end of debugging, the trace main body 19 can be easily removed.

[Brief description of the drawings]

FIG. 1 is a block diagram showing a configuration of a first embodiment.

FIG. 2 is an inspection target table 18 according to the first embodiment.
FIG. 3 is a diagram showing the configuration of FIG.

FIG. 3 shows a trace buffer 20 according to the first embodiment.
FIG. 3 is a diagram illustrating a configuration of a sub-trace buffer (and a sub-trace buffer).

FIG. 4 is a diagram showing a configuration of a trace flag 21 according to the first embodiment.

FIG. 5 is a diagram showing a flowchart of a write protection exception handler 16;

FIG. 6 is a diagram showing a flowchart of processing of the trace information management unit 22 in the trace main body 19 in steps S2 and S3.

FIG. 7 is a diagram showing a flowchart of processing of the trace buffer control unit 23 in the trace main body 19 in step S6.

FIG. 8 is a diagram showing a configuration of an inspection target table 18 according to the second embodiment in which FIG. 2 is modified.

FIG. 9 is a diagram showing a configuration of an inspection target table 18 according to the third embodiment in which FIG. 2 is modified.

FIG. 10 is a diagram showing a flowchart of the trace information management unit 22 in the third embodiment in which FIG. 6 is modified.

FIG. 11 is a diagram showing a configuration of an inspection target table 18 according to the fourth embodiment in which FIG. 2 is modified.

FIG. 12 is a diagram showing a flowchart of the trace information management unit 22 according to the fourth embodiment in which FIG. 6 is modified.

FIG. 13 is a block diagram showing a configuration of the fifth embodiment.

FIG. 14 is a diagram showing a conventional debugging device.

[Explanation of symbols]

10 debugger body, 11 debug target program,
12 instruction execution unit, 13 memory management unit,
14 memory unit, 15 inspection target address, 16
Write-protection exception handler, 17 write-protection attribute setting unit, 18 inspection target table, 19 trace body, 2
0 trace buffer, 21 trace flag, 22
Trace information management unit, 23 Trace buffer control unit.

Claims (9)

[Claims] 1. A method according to claim 1, wherein certain data in the program to be debugged is specified as data to be inspected, an exception stop condition for stopping the program to be debugged is specified, a page including the data is write-protected, and a write-protection exception for the data is specified. Trace information for that data is stored in response to the occurrence of
A program execution tracing method characterized in that when a generated write protection exception matches an exception stop condition, a debug target program is stopped and trace information on the data is presented so far. 2. A program execution tracing method having the following elements: (a) a debugger body for an operator to perform a debugging operation; (b) an instruction execution unit for executing a program to be debugged; A memory unit in which data is placed. (D) A protection mechanism that enables access control of the memory unit in page units, and a write protection exception occurs when data is written to data in a page for which write protection is set. (E) The address of certain data in the program to be debugged (this is called an address to be inspected) and an exception for stopping the program to be debugged when a write protection exception occurs for that data Inspection target table holding stop conditions (f) Debugging target program A write protection attribute setting unit that sets information on an address to be inspected and an exceptional stop condition in the inspection target table and operates a memory management unit to prohibit writing to a page including the data; The program is started in response to the write protection exception notification for the address to be checked in the program. If the exception stop condition is satisfied, the debug target program is stopped and the trace information up to that point is presented. (H) A trace body that stores trace information when a write occurs to a check target address based on a trace processing request of the write protection exception handler. 3. The trace body includes: (i) a trace buffer for holding trace information in the trace body;
(J) a trace information management unit for writing trace information to a trace buffer within the trace body; (k)
3. The program execution trace method according to claim 2, further comprising a trace buffer control unit for reading trace information from a trace buffer in the trace body. 4. The trace buffer according to claim 3, wherein the trace information holds at least a value to be changed, an instruction execution address when an exception occurs, and process information that caused the exception, as trace information. The described program execution trace method. 5. The trace body further holds a trace flag for designating whether or not to perform sub-trace on an address near the data for which write protection is set, and the trace body includes an address near the address to be inspected. 4. A program execution tracing method according to claim 3, wherein a sub-trace is performed on the program execution trace. 6. The inspection target table has a second exception stop condition that designates a process as one of the conditions for stopping the debug target program, and the write protection exception handler sets the second exception stop condition make use of,
3. The program execution trace method according to claim 2, wherein the debug target program is stopped when a write protection exception from the process occurs. 7. The inspection target table includes a trace selection flag for each inspection target address, and the write protection exception handler uses the trace selection flag to select whether to execute a trace for each inspection target address. The program execution trace method according to claim 2, wherein: 8. The inspection target table includes a trace target process condition in which a certain process or a process satisfying a certain execution level condition is designated as a trace target process, and the trace body uses the trace target process condition. 3. The program execution trace method according to claim 2, wherein the trace is executed only when the designated process or the process satisfying the designated execution level condition writes to the inspection target address. 9. The program execution trace method according to claim 2, wherein said trace main body is arranged in a debugger main body.