JPH11345143A - In-circuit emulator - Google Patents

Abstract

(57) [Summary] [PROBLEMS] To re-execute a user program after an interrupt process to a user program in a stop mode state, the user program returns to a state before the user program was stopped. SOLUTION: Interrupt processing during execution of a user program is confirmed (S1). The stop of the user program is confirmed by the interrupt processing, and the operation mode (normal mode, stop mode, etc.) before the stop is read (S2). further,
When an interrupt occurs, the saved state information is read into the stack area (S3). The interrupt process is executed, the re-execution of the user program is confirmed (S4), and the stop address of the stack area is changed to a dummy return address by the stop mode confirmation (S5) before the stop, and the dummy return address is changed. Write an instruction to enter the stop mode (S8), and write an instruction to branch unconditionally to the return address of the user program (S8).
9). Thereafter, a return instruction is executed to start the process of re-executing the user program (S6).

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

[0001] 1. Field of the Invention [0002] The present invention relates to an in-circuit emulator for improving debugging efficiency in a development tool for application software of a microcomputer.

[0002]

2. Description of the Related Art In recent years, importance has been placed on how to suppress electric power during standby of electric appliances. Therefore, in order to realize low power consumption of electrical products, besides the necessary processing of microcomputers used in many electrical products, stopping the original oscillation of the microcomputer has a large effect, One of the operation modes of the microcomputer has a function of stopping original oscillation (hereinafter, referred to as a stop mode) to realize low power consumption. FIG. 5 shows a flow of an operation of debugging application software using the stop mode with a conventional in-circuit emulator (hereinafter referred to as ICE). FIG. 5 shows a state when the operation by the ICE interrupt processing is executed during the stop mode of the user program. FIG.
6A is a flowchart showing a main routine of a user program having a stop mode for debugging, FIG. 6B is a flowchart showing interrupt processing of the user program, and FIG. 6C is a flowchart showing ICE interrupt processing.

In FIGS. 6 (a), 6 (b) and 6 (c), 1
Is a main routine of a microcomputer user program, 2 is an interrupt process of the user program, 3 is an ICE interrupt process which is executed when an operation of stopping the main routine 1 is performed and an ICE interrupt occurs, and 4 is Normal processing including an initial setting routine of the user program, 5 is an instruction to enter a stop mode, 6 is a normal processing performed after the interrupt processing 2 of the user program occurs during the stop mode, and 7 is in the middle of the normal processing 4. The first forced break is caused by the occurrence of the ICE interrupt processing 3 for stopping the user program, and the first forced break 8 is caused by the occurrence of the ICE interrupt processing 3 while waiting for the occurrence of the interrupt processing 2 in the stop mode by the instruction 5 for entering the stop mode. The second forced break 9 is a return instruction for returning from the interrupt processing 2 of the user program to the main routine 1, 1 Is an ICE return instruction of the ICE interrupt processing 3 for re-executing the user program from the stop state, and 11 is controlled by the ICE control software by the ICE interrupt processing 3 to be executed by stopping the execution of the user program. This is a normal interrupt process for performing debugging and the like.

FIG. 7 shows a main routine of FIG.
FIG. 8C is a state transition diagram in the flowchart of the ICE interrupt processing shown in FIG. 8C. FIG. 8 is a diagram showing a stack area for saving state information due to occurrence of an interrupt processing. In FIG. 8, 1
2 is a save area for the flag status, 13 is a save area for the return address of the program, and 14 is a save area for various statuses. These save areas are automatically saved and stored when an interrupt occurs.

A specific example of the operation of the conventional example will be described with reference to FIGS. First, during the normal processing 4 of the main routine 1 in the user program, an external interrupt of the first forced break 7 for stopping the user program is generated. The ICE interrupt process 3 of the first forced break 7 causes a transition to an ICE interrupt process. This IC
In the E interrupt processing 3 as well, similarly to the interrupt processing 2 of the user program, the state of the user program is saved in the stack area shown in FIG. Further, with the control software of the ICE, the contents of the stack area saved and stored can be read, and the state when the user program is stopped can be displayed on the monitor. Since the user is executing ICE interrupt processing 3 other than the user program, the user program appears to be stopped. Further, when the user program is re-executed, the resources saved in the stack area when the first forced break 7 occurs are restored by executing the ICE return instruction 10 of the ICE interrupt processing 3.

Next, during the stop mode according to the instruction 5 for entering the stop mode of the main routine 1, the second
ICE interrupt processing 3 of forced break 8 of
In this case, the flow of operation up to the stop of the user program is the same as that described above, and thus will be omitted, and only different parts will be described.

[0007] Since the user program is in the stop mode, the oscillation of the user program is stopped. Therefore, the occurrence of the ICE interrupt processing 3 cancels the stop mode and starts the oscillation. Hereinafter, the oscillation state is referred to as a normal mode. That is, the ICE interrupt processing 3 is executed in the normal mode. In the case of this operation, since the re-execution of the user program is stopped in the stop mode, it is necessary to return to the original stop mode.

However, if the stop mode is entered before the ICE return instruction 10 in the ICE interrupt process 3, the stop mode is entered during the ICE interrupt process 3, and the operation mode immediately returns to the operation mode before the user program. I can't go back. For this reason, when re-executing in such a conventional case, the ICE control software has issued a warning such as "Please enter normal mode because stop mode is in progress." Therefore, the user changes the register for controlling the operation mode by ICE, specifies a start address to be re-executed, or resets and re-executes.

[0009]

In the in-circuit emulator having such a configuration, when debugging application software having a stop mode for stopping the source oscillation of the microcomputer in the user program,
In order to perform the ICE interrupt processing during the stop mode of the user program and then return to the original stop mode so that the user program can be re-executed, an instruction to enter the stop mode before the ICE return instruction of the ICE interrupt processing is provided. Even if it is executed, there is a problem that the stop mode is entered during the interrupt processing of the ICE before returning to the execution mode of the user program, and it is not possible to return to the original state.

In order to automatically switch back to the stop mode after the processing of the control software of the ICE, it is necessary to return to the address set in the stop mode in the user program. Even then, the next instruction may be executed,
If the instruction is a branch instruction, there is a problem that it cannot be determined where to return.

[0011] The present invention is directed to solving the above-mentioned problem of the prior art, and is directed to re-executing the user program after performing an ICE interrupt process on the user program stopped in the stop mode. In this case, it is an object of the present invention to provide an ICE (in-circuit emulator) having excellent operability that can return a user program to a state before the user program was stopped without any restrictions.

[0012]

In order to achieve the above object, an in-circuit emulator according to the present invention has a function of stopping original oscillation in an operation mode of a microcomputer and a control software of the in-circuit emulator for debugging. And a memory readable and writable under the control of control software.

According to the above configuration, after the end of the interrupt processing that has occurred in the stop mode of the user program,
The user can return to the stop mode before stopping the user program without any restrictions.

[0014]

Embodiments of the present invention will be described below in detail with reference to the drawings. FIG. 1 is a diagram showing an example of an IC during a stop mode of a user program according to the present embodiment.
It is a figure showing that when the E interrupt processing is performed and the user program is re-executed thereafter, the original stop mode is entered. FIG. 2 is a flowchart showing the processing operation of the control software of the ICE according to the embodiment of the present invention. FIG. 3 is a diagram showing how to use the stack to enter the stop mode by re-executing the user program after the ICE interrupt processing, and FIG. 4 shows instructions at each address in the user program which have shifted to the stop mode and are in a standby state. FIG.

In FIG. 3, a flag status save area 12 and various statuses 14 are an area for automatically saving the flag status and an area for saving the various statuses when an interrupt occurs, as shown in FIG. Yes, 15
Is a dummy return address obtained by rewriting the return address 13 of the program of FIG. 8 by the ICE control software, 16 is an instruction to enter the stop mode rewritten by the ICE control software, and 17 is a return of the main routine. This instruction unconditionally branches to an address. In FIG. 4, reference numeral 19 denotes an instruction to enter a stop mode in the user program, reference numeral 20 denotes a first instruction immediately after the instruction to enter the stop mode, and reference numeral 21 denotes an instruction when the stop mode is released by a user interrupt. The second instruction 22, which is executed first, is waiting for an interrupt return.

First, the operation of the ICE interrupt process generated during the stop mode of the user program when the execution of the user program is stopped will be described with reference to FIGS. When an instruction 19 for entering the stop mode at address A is executed in the main routine of the user program shown in FIG. 4, the first instruction 20 at address B follows because the next instruction is also prefetched (prefetched). Executed. Up to this point, the normal mode is set, and the first instruction 20 at the address B is set.
Immediately after executing, the oscillation is stopped and the mode is set to the stop mode. In this stop mode, the input of the interrupt return wait 22 is waited for, and the return to the main routine by the return of the interrupt from the user is executed from the second instruction 21 at the address C to be in the normal mode.

Here, in the standby mode of the interrupt return wait 22 in the stop mode, when the ICE interrupt processing of the ICE control software for stopping and debugging the user program occurs, the stop mode is set to the interrupt of the user program. As in the case of the loading process, the mode is released and the normal mode is set. The state of the stack area at this time is saved as shown in FIG. 8, and the return address 13 in FIG. 8 saves the address C of the second instruction 21 shown in FIG.

The operation of the ICE control software will be described with reference to the flowchart of FIG. During execution of the user program, it is checked whether or not the user program has been stopped due to the occurrence of an execution stop process (such as an interrupt process due to a forced break) (S1). Processing S1
In step (2), when it is confirmed that the user program has stopped due to the execution stop processing, the microcomputer reads the operation mode (normal mode, stop mode, etc.) before the execution of the user program stops (S2). Further, the CPU reads the status information read from the general-purpose register due to the occurrence of an interrupt by the ICE or the like and is saved in the stack area (S3), and executes the processing of the generated interrupt. Thereafter, it is confirmed whether or not a return instruction for the interrupt processing or an instruction for re-executing the user program by a user operation has been issued (S4).

In step S4, when the re-execution command is confirmed, it is confirmed from the information read in step S2 whether the state before the stop of the user program is the stop mode (S5). When the stop mode is not set in the process S5, the process of re-executing the user program is started by executing a return instruction for writing the address and status information saved in the stack area to the general-purpose register (S6).

In the stop mode in step S5, a process of changing the return address saved in the stack area to a dummy return address is performed (S7), and the stop mode is set to the area designated as the dummy return address. An instruction to be inserted is written (S8), and an instruction for unconditionally branching is written to a normal return address of the user program (S9). After the above processing, a return instruction is executed to start the re-execution of the user program (S6).

More specifically, when the user program is re-executed by the operation after the ICE interrupt processing generated in the stop mode state and the same stop mode as before the interruption is executed, the re-execution instruction of the processing S4 shown in FIG. The following changes are made by the control software of the ICE according to the confirmation. First, in step S5, it is confirmed whether the operation mode before the stop of the user program is the stop mode. In the stop mode, in the process S7, the return address 13 (see FIG. 8) evacuated to the address Y in the stack area stores the address C which is the return address to the main routine shown in FIG. The address is changed to the address V as the dummy return address 15. Next, in step S8, an instruction 16 for entering the stop mode is written in the address V of the stack area, and in step S9, the next address W is unconditionally branched to the return address of the main routine. Write the instruction to branch.

With such pre-processing, ICE
When the ICE return instruction of the interrupt processing is executed, the microcomputer automatically returns the flag status 12, the dummy return address 15, and various statuses 14 of the addresses X, Y, and Z in the stack area to the general-purpose register in FIG. Then, the user program is re-executed. And
The user program is to be executed from the dummy return address 15, ie, address V, and the instruction 16 to enter the stop mode is executed to enter the stop mode. Since the oscillation stops after the execution of the next instruction, address W, the user program can operate the ICE in the stop mode without paying any attention to the user.

The instructions at addresses V and W in the stack area must use instructions in which the flag status 12 and the various statuses 14 do not change. In the above description, the description is made using the stack area. However, the present invention can be similarly implemented using a rewritable memory in an unused area.

[0024]

As described above, according to the present invention,
ICE execution and stop operations can be performed in the stop mode of the user program without imposing a burden on the user, resulting in an effect that debugging can be performed efficiently.

[Brief description of the drawings]

FIG. 1 is a diagram showing that an original STOP mode is entered upon re-execution of a user program after performing an ICE interrupt process during a stop mode of the user program according to the embodiment of the present invention;

FIG. 2 is a flowchart showing a processing operation of ICE control software according to the embodiment of the present invention;

FIG. 3 is a diagram showing how to use a stack for entering a stop mode by re-executing a user program after an ICE interrupt process according to the embodiment of the present invention;

FIG. 4 is a diagram showing an instruction of each address in a user program according to the embodiment of the present invention, which has entered a stop mode after entering a stop mode.

FIG. 5 is a diagram showing a state when an operation by an ICE interrupt process in a stop mode of a conventional user program is executed.

6A is a flowchart showing a main routine of a user program having a stop mode for debugging, FIG. 6B is a flowchart showing interrupt processing of the user program, and FIG. 6C is a flowchart showing ICE interrupt processing;

FIG. 7A shows a main routine of FIG. 6A and FIG.
State transition diagram in CE interrupt processing flowchart

FIG. 8 is a diagram showing a stack area for saving state information due to occurrence of interrupt processing;

[Explanation of symbols]

 1 Main routine 2 Interrupt processing 3 ICE interrupt processing 4,6 Normal processing 5,16,19 Instruction to enter stop mode 7,8 Forced break 9 Return instruction 10 ICE return instruction 11 Normal interrupt processing 12 Flag status 13 Return address 14 Various statuses 15 Dummy return address 17 Instruction that branches unconditionally to main routine return address 20 First instruction 21 Second instruction 22 Waiting for interrupt return

Claims (1)

[Claims] The microcomputer has a function of stopping a source oscillation in an operation mode of a microcomputer, control software of an in-circuit emulator for debugging, and a memory readable and writable under the control of the control software. An in-circuit emulator wherein the operation mode is set after the end of the interrupt processing generated in the operation mode in which the operation is stopped.