JP2000353109A - Emulator and emulation system - Google Patents

Abstract

PROBLEM TO BE SOLVED: To easily detect an address and the contents of data only by one execution of a program when an error occurs and to improve the efficiency of debugging. SOLUTION: A monitoring circuit 13 stores the same program as a program to be stored in a target memory 31 also in a temporary memory 12 by the same address. At the time of executing the program stored in the memory 31 by an MCU 11, the circuit 13 reads out the same data as the data read out from the memory 31 and a comparator 14 compares both the data with each other. When both the data coincide with each other by the comparison, the MCU 11 executes the read data, and when both the data do not coincide with each other, stores the address and both the data in the memory 12 and detects an error. Then a debugger 2 displays the error detection address and the data so that a user can easily recognize the error generated during the execution of the program.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

[0001] 1. Field of the Invention [0002] The present invention relates to an emulation system for a microcomputer development support system, and more particularly to an emulator having a memory access error detection function.

[0002]

2. Description of the Related Art Conventionally, in order to develop a program to be mounted on a microcomputer or the like, the operation of the microcomputer is monitored by emulating the operation of the microcomputer by an emulator 1 as shown in FIG. I have. This emulator 1 is connected to a debugger 2 operating on a host computer.

The MCU 11 in the emulator 1 executes a program on the emulation memory 12 to perform a mimic operation of the microcomputer, and the mimic operation is monitored using the debugger 2 as a window.

[0004]

Here, a target 3 mounted on a board of a printer, for example, is connected to an emulator 1 as shown in FIG. When the above program is executed by the MCU 11, data reading is performed because of the influence of noise on the probe 4, the long signal line connecting the MCU 11 and the target memory 31, and the fact that the target is incomplete and the noise is likely to be loaded. When writing, data may change unexpectedly.

Conventionally, if such a problem occurs during access to the target memory 31 during execution of a program, the program may run out of control and become uncontrollable, or it may appear that the program is executing normally. Running with different data could result in errors in later results.

Conventionally, in order to find the cause of such an error, (1) the trace data is referred to, and the location where the error has occurred is individually searched to find the trace.

(2) When an event trigger is applied in a suspicious place, it is necessary to find the cause of the error by using a method such as real-time execution, step execution, stop, etc. In any case, debugging is extremely troublesome. There was such a problem.

SUMMARY OF THE INVENTION The present invention has been made to solve the above-mentioned conventional problems. An object of the present invention is to make it possible to easily detect an address and data content at the time of occurrence of an error by executing a program once. An object of the present invention is to provide an emulator capable of improving debugging efficiency and an emulation system using the emulator.

[0009]

According to one aspect of the present invention, there is provided an emulator for executing a program stored in an externally connected target memory. A temporary memory for storing the same program as the program being read, monitoring means for reading from the temporary memory data at the same address as the data read from the target memory, and data for monitoring the data read from the target memory. A comparison means for comparing the data read by the means, and a processing means for executing the read data when both data match by the comparison means.

A feature of the invention according to claim 2 is that when the comparison means does not agree with each other, an error detection means for storing the data and a read address of the data is provided.

According to a third aspect of the present invention, the monitoring means constantly monitors a signal to be written in an area allocated to the target memory, and when this signal becomes valid, the address information and data are also stored in the temporary memory. Write.

A feature of the invention according to claim 4 is that, when both data do not match in the comparing means, the processing means processes data having a higher priority and continues execution of the program.

According to a fifth aspect of the present invention, in an emulation system comprising a debugger for debugging a program and an emulator connected to the debugger, the emulator is the same as the program stored in the target memory. A temporary memory for storing a program, monitoring means for reading data at the same address as the data read from the target memory from the temporary memory, and data read from the target memory and read by the monitoring means. A comparing means for comparing data; and a processing means for executing read data when the two data match by the comparing means, and when the two data do not match by the comparing means of the emulator, these data and Error including the read address of these data Display means for displaying the history information is to comprise the debugger.

[0014]

Embodiments of the present invention will be described below with reference to the drawings. FIG. 1 is a block diagram showing an emulation system according to an embodiment of the present invention.
However, the same parts as those in the conventional example will be described using the same reference numerals. The emulator 1 has an MCU (microcomputer unit) 11, a temporary memory 12, a monitoring circuit 13, and a comparison circuit 14. The emulator 1 connects the target 3 on which the target memory 31 is mounted via the probe 4, and is connected to the debugger 2 operating on the host computer.

The temporary memory 12 stores a program having the same contents as the target memory 31. Monitoring circuit 13
Reads the target memory mapping information stored in the temporary memory 12 and reads the target memory 3
The read / write signal for accessing 1 is monitored. The comparison circuit 14 compares the data read from the temporary memory 12 with the data read from the target memory 31.

The debugger 2 has a function of displaying a window (hereinafter, referred to as a compare window) as shown in FIG. 5 for displaying an error history stored in the temporary memory 12, similar to the memory window and the like. Data can be read and written on the debugger 2.

FIG. 2 is a schematic diagram showing an example of a storage area partitioned in the temporary memory 12. The temporary memory 12 is a start address / size storage area 121 of the target memory,
A program load area 122, an address / data storage area 123 at the time of writing (WR), an error address / data storage area 124, and a reset vector jump destination address storage area 125 are provided.

Next, the operation of this embodiment will be described. First, a program to be debugged is loaded into the emulator 1 from the debugger 2. The MCU 11 writes the loaded program into the target memory 31. At this time, the monitoring circuit 13 stores the program in the temporary memory 12
Is also written in the program load area 122. That is, the monitoring circuit 13 uses the target memory 3 during memory mapping.
Always monitor the signal to be written to the area assigned to 1,
When this signal becomes valid, the address information and data are also written in the address and data storage area 123 of the temporary memory 12 at the time of writing. Also, when loading a program such as an abs file, the monitoring circuit 13 loads the same data as the data loaded into the target memory 31 into the program load area 122 of the temporary memory 12 in the same manner as described above.

Thereafter, the MCU 11 stores the target memory 3
1. Execute the program stored in 1.

While the MCU 11 is executing the program, the monitoring circuit 13 constantly monitors the read signal from the MCU 11 to the target memory 31 and fetches the read signal to the target memory 31 and at the same time reads the contents of the same address in the temporary memory 12.

The data read from the target memory 31 and the data read from the temporary memory 12 are compared by the comparing circuit 14, and the result of the comparison is input to the MCU 11.

The MCU 11 determines that the data compared by the comparison circuit 14 match, and determines that there is no problem.
The execution of the program is continued as it is with the data read from Step 2.

The data used for executing the program may be data read from the target memory 31. However, if the data compared by the comparison circuit 14 do not match, the temporary memory 12 and the target memory 31
The accessed address and data are stored in the error address / data storage area 124. In addition, one of the following two treatments will be taken.

A) A break is applied and the contents of each memory are immediately displayed by a debugger (forced event break). b)
A priority is given to either the temporary memory 12 or the target memory 31 in advance, and the execution of the program is continued with the data with the higher priority. Normally, priority is given to data read from the temporary memory 12 which is not easily affected by noise or the like.

In either method, the contents of the memory at the time of error detection after execution of the program can be confirmed in the compare window of the debugger 2 shown in FIG.

In this compare window, Add
The address indicates the execution address, the Count indicates the number of times the execution address has been read, the Temp Mem indicates the data read from the execution address in the temporary memory 12, and the User Mem indicates the data read from the execution address in the target memory 31. You.

For example, 000055aa is read from the temporary memory 12 at the address of 00f01000, and 000055ab is read 153 times from the target memory 31, respectively, indicating that the data is different.

Type is a button for changing the display method. For example, Mem is a button for operating and stopping the monitor window monitoring function. Memory Full is an error address and data storage area 124 in the temporary memory 12.
Write, stop, overwrite (o
ver) and a button for canceling (comp) saving of the same data, and Update is a button for updating the display data.

Here, a method of storing data in the temporary memory 12 will be described below. 1) The start address / size information of the area allocated to the target memory 31 by the monitoring circuit 13 at the time of memory mapping is stored in the start address / size storage area 121 of the target memory 31.
To be stored. This is used to check through the monitoring circuit 13 whether a read / write signal is being output to the target memory 31 during execution of the program.

2) When loading a program (abs file, etc.) into the target memory 31, the reset vector jump destination address is also stored in the reset vector jump destination address storage area 125 of the temporary memory 12, and the program contents are also stored in the program load area 122. It is loaded as shown in FIG. When a reset occurs, the temporary memory 12
However, the jump address of the program is obtained, and the access to the start address stored in the program load area 122 is speeded up.

3) When writing data to an address in the target memory 31 during execution of the program, the address and data are stored in the WR address and data storage area 123 of the temporary memory 12 as shown in FIG. Save it. At this time, when writing many bytes continuously from the address, the address and the write size of the data are recorded as shown in FIG. 4B, and the data to be written thereafter is stored. As a result, the address information can be deleted, so that the memory storage size can be reduced.

4) When loading a program, the temporary memory 12
The program load area 122 of the target memory 31
Use from the end of the to the end of storing the program. At this time, the WR address / data storage area 1
23 starts from the end.

5) Error address / data storage area 12
4 stacks data from the reset vector jump destination address area 125 in a stack format.

6) From the above 4) and 5), it is possible to efficiently use the memory capacity for storing the write data and the error data whose data amount varies during the execution of the program. However, a minimum size is specified for these two areas so that the data amount of one of them does not exceed the limit value, no matter how much.

If the error address / data storage area 124 or the WR address / data storage area 123 has been used up to the limit during execution of the program of the MCU 11, one of the following measures is selected. 1) Stop recording data. 2) Overwrite old contents. 3) In the case of data at the time of writing, if the same data as that stored in the past is to be stored, it is not stored.

According to the present embodiment, the same program as that stored in the target memory 31 is stored in the temporary memory 12 in the emulator 1 and the MCU 1
When 1 reads data from the target memory 31, it also reads the data at the same address in the temporary memory 12 and compares both data, so that no error occurs in one execution of the program even if no setting is made during debugging. The address and data content at the time of occurrence can be confirmed. In addition, the location where an error has occurred can be found without repeatedly executing the program. Therefore, it is possible to focus on debugging after confirming the occurrence of the error, thereby improving debugging efficiency. Further, it is unnecessary to set an event trigger or a break on the assumption of an error occurrence location, and it is possible to save trouble of searching for an error location from trace data.

[0037]

As described above in detail, according to the emulator of the present invention, the address and data contents at the time of occurrence of an error can be easily detected by executing the program once even if no settings are made at the time of debugging. And the debugging efficiency can be improved.

According to the emulation system of the present invention, error history information is displayed on the debugger, and debugging efficiency can be significantly improved.

[Brief description of the drawings]

FIG. 1 is a block diagram showing an emulation system according to an embodiment of the present invention.

FIG. 2 is a schematic diagram showing an example of a storage area partitioned into a temporary memory shown in FIG.

FIG. 3 is a diagram showing an example of contents of a program stored in a program load area shown in FIG. 2;

FIG. 4 is a diagram showing a method of storing addresses and data stored in an address / data storage area at the time of WR shown in FIG. 2;

FIG. 5 is a diagram showing a display example of a compare window displayed on the debugger shown in FIG. 1;

FIG. 6 is a block diagram showing a configuration example of a conventional emulation system.

FIG. 7 is a block diagram showing another configuration example of a conventional emulation system.

[Explanation of symbols]

 DESCRIPTION OF SYMBOLS 1 Emulator 2 Debugger 3 Target 4 Probe 11 MCU 12 Temporary memory 13 Monitoring circuit 14 Comparison circuit 31 Target memory

Claims (5)

[Claims] 1. An emulator for executing a program stored in an externally connected target memory, comprising: a temporary memory for storing a program identical to the program stored in the target memory; and an emulator read from the target memory. Monitoring means for reading data at the same address as the read data from the temporary memory; comparing means for comparing the data read from the target memory with the data read by the monitoring means; An emulator comprising: processing means for executing read data when they match. 2. The emulator according to claim 1, further comprising an error detection unit for storing the data and a read address of the data when the two data do not match in the comparison unit. 3. The monitoring means constantly monitors a signal to be written to an area allocated to the target memory, and when the signal becomes valid, writes the address information and data to the temporary memory. Claim 1
Or the emulator according to 2. 4. The processing means, if the two data do not match in the comparing means, processes the data having a higher priority,
2. The program according to claim 1, wherein the program execution is continued.
The emulator according to any one of claims 1 to 3. 5. An emulation system comprising a debugger for debugging a program and an emulator connected to the debugger, wherein the emulator comprises: a temporary memory for storing a program identical to the program stored in the target memory; Monitoring means for reading, from the temporary memory, data at the same address as the data read from the target memory; and comparing means for comparing the data read from the target memory with the data read by the monitoring means. Processing means for executing the read data when the two data match by the comparing means, and when the two data do not match by the comparing means of the emulator, these data and a read address of the data are included. Display error history information An emulation system comprising a display unit provided in the debugger.