JP2000020352A - Stack overflow detecting method and stack underflow detecting method - Google Patents

Abstract

PROBLEM TO BE SOLVED: To unnecessitate debugger setting at the time of using a detection function and to unnecessitate the update of break conditions even when the break conditions are changed by frequent program correction in debugging. SOLUTION: When executing a program, a stack overflow detection address and stack pointer address preset to a stack overflow register 1 and a stack pointer register 2 are compared and in the case of coincidence, an interruption request is generated and the debugger executes break processing while using a leading address 6a of break processing preset to an overflow interruption vector area 6b.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a debugging system for easily detecting, at the time of debugging, a stack overflow or a stack underflow which is one of the causes of a runaway during debugging of a program executed on an embedded system. And a stack underflow detection method.

[0002]

2. Description of the Related Art FIG. 6 is a diagram for explaining a stack overflow. In FIG. 6, reference numeral 101 denotes a memory space. The memory area 101 has a data area 102
And a program area 103 for storing a program (hereinafter, referred to as a program) mounted on the embedded system. Data area 102 and program area 1
03, a stack area 104 is provided. Here, the stack consumption is determined in consideration of the program algorithm, the operation state of the interrupt function, the timing of accepting an interrupt request, and the like, when a function, a subroutine, and an interrupt program are received multiple times, or when a stack operation instruction is issued in an interrupt enabled state. Estimation is performed using desk calculation or stack consumption calculation software based on the combination in the case of execution.

This method is an estimation. If there is an estimation error, data is excessively saved in the stack area 104, and the stack area 104 grows beyond the area to the original data area 102. As shown in FIG. 7, a stack overflow occurs that destroys the original data area 102. If the corrupted data is used by the program, the program will perform illegal processing, and in the worst case, the program will run away. It is difficult to quickly determine the cause of this runaway (stack overflow) during debugging.

Therefore, it is necessary to stop the program by a debugger before the program runs away, that is, immediately after the occurrence of a stack overflow, and to pursue the cause. In the current microcomputer function and debugger function, a hardware break that breaks by using an address signal of a program or a variable and a signal when the address is accessed as a trigger can be considered. In this method, the break address is set at the top of the stack (the lowest address in the stack area) -1, and an execution break is set when arbitrary data is read from or written to the set address. The features of this method are "break after execution", "detailed break conditions can be set by debugger control software", "break condition needs to be reset if variable address is changed by changing target program", etc. It is.

[0005]

Since the conventional stack overflow detection method is configured as described above,
If the stack pointer changes after changing the program,
There are problems such as resetting with debugger control software is required, and in the case of multitask programming, it is necessary to set break conditions for the number of tasks.

SUMMARY OF THE INVENTION The present invention has been made to solve the above problems, and has as its object to provide a stack overflow detection method and a stack underflow detection method which can eliminate the need for setting a debugger when using a detection function. And Another object of the present invention is to provide a stack overflow detection method and a stack underflow detection method which can eliminate the need for updating break conditions even when break conditions are changed due to frequent program correction during debugging. I do. Still another object of the present invention is to provide a method for detecting a stack overflow and a method for detecting a stack underflow that can break before execution of an instruction.

[0007]

A method for detecting a stack overflow according to the present invention is a method for detecting a stack overflow of a debugger at the time of debugging an embedded program. The stack overflow detection address at which overflow occurs is set in the first register, the stack pointer address is set in the second register at the initial setting stage of the program, and the debugger sets the start address of the break processing to the interrupt vector immediately before the execution of the program. If the stack overflow detection address and the stack pointer address match when the program is executed and the stack pointer address matches, an interrupt request is generated and the debugger uses the break processing start address to execute the break processing. It is intended to run.

In the stack overflow detection method according to the present invention, a stack overflow detection address of each task is set in a system storage area of an operating system, and a stack overflow detection address of a task to be executed next at the time of dispatch is stored in a system storage. The data is read from the area and set in the first register.

A method of detecting a stack underflow according to the present invention is a method of detecting a stack underflow of a debugger when debugging an embedded program, wherein the stack underflows when data is excessively returned from the stack in a program initialization stage. Set the underflow detection address in the first register,
The stack pointer address is set in the second register at the initial setting stage of the program, the debugger sets the start address of the break processing in the interrupt vector area immediately before the program is executed, and the stack underflow detection address is set when the program is executed. When a match is found between the address and the stack pointer address, an interrupt request is generated, and the debugger executes the break process using the start address of the break process.

In the stack underflow detection method according to the present invention, a stack underflow detection address of each task is set in a system storage area of an operating system, and a stack underflow detection address of a task to be executed next at the time of dispatch is set. Is read from the system storage area and set in the first register.

[0011]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS One embodiment of the present invention will be described below. Embodiment 1 FIG. FIG. 1 is an explanatory diagram of a stack overflow detection method according to Embodiment 1 of the present invention. In FIG. 1, reference numeral 1 denotes a stack overflow register (hereinafter, referred to as SOR) as a first register in which a stack overflow detection address that overflows when data is excessively saved on the stack in a program initial setting stage is set. is there. 2 is a stack pointer register (hereinafter referred to as S) as a second register in which a stack pointer address is set at a program initial setting stage.
PR). Since the program uses a subroutine and an interrupt function, the setting of the stack pointer address is performed at the initial setting stage of the program.

Reference numeral 3 denotes a comparator which compares a stack overflow detection address with a stack pointer address when the program is executed, and generates an interrupt request when the addresses match. Reference numeral 4 denotes an arbitrary register. In this register 4, an overflow interrupt permission bit 4a is set. That is, the interrupt enable bit for the overflow interrupt is enabled to enable the overflow interrupt immediately after the initialization and immediately before the execution of the main program.

Here, since this preparation processing is performed only on the microcomputer side, the stack overflow detection function cannot be used by itself. In other words, the processing of the debugger must also be linked with the overflow interrupt of the microcomputer. In order to cooperate, the debugger can perform break processing when an overflow interrupt occurs.
The debugger sets the break processing start address 6a in the overflow interrupt vector area (interrupt vector area) 6b in the interrupt vector table area 6 of the ROM area 5 immediately before executing the program.

Next, the operation will be described. Each time the microcomputer executes an instruction, the SPR to be output at that time
Stack pointer address and SOR set to 2
The comparator 3 compares the stack overflow detection address set to 1 inside the microcomputer.

Here, if data is to be saved on the stack beyond the stack capacity estimated during the execution of the program, the stack pointer address set in SPR2 and the stack set in SOR1 at that time. The overflow detection address is compared with the overflow detection address in the microcomputer by the comparator 3 and coincides with each other. At this time,
An interrupt request occurs for the first time. This interrupt accepts a request immediately like a reset. Using this request, the debugger breaks the program and performs processing after the break.

Here, even if the stack overflow detection address changes due to the program being modified in the debugging process, if a label is assigned to the stack overflow detection address on the program and the SOR1 is set by the label, user debugging No time resetting is required.

As described above, according to the first embodiment, unlike the stack overflow detection by the hardware break function of the debugger, the effect that the debugger setting when using the detection function is unnecessary is obtained. In addition, even when a break condition (here, a stack overflow detection address) is changed due to frequent program modification at the time of debugging, there is an effect that the break condition need not be updated. Further, an effect that a break before execution of an instruction is enabled is obtained.

Embodiment 2 FIG. Embodiment 2 of the present invention
Is an application of the present invention to detection of stack overflow of a user stack of each task of a multitask program. The schematic circuit configuration in that case is the same as that of FIG. 1, but is not realized by the function of the current real-time OS (hereinafter, referred to as OS). FIG. 2 shows an additional configuration of the OS to be realized.

As shown in FIG. 2, resource information managed by the OS is stored in the system storage area 7 of the OS.
In order to realize this function, a stack overflow detection address of the stack of each task is additionally registered as new management information, and a stack overflow detection address storage area 8 is provided. The address for detecting a stack overflow may be placed in the task control block.

The stack overflow detection address storage area 8 is composed of a system stack overflow detection address 9, a task stack overflow detection address 10 of ID1, a task stack overflow detection address 11 of ID2, and the like.

Further, as a function of the OS, the stack overflow detection address of the task to be executed next at the time of dispatch is read from the stack overflow detection address storage area 8 and set in the SOR1. When the system stack is used during the system call processing or during the execution of the interrupt program, the system stack overflow detection address 9 is set to SOR1 before executing the processing.

Next, the operation will be described. When attempting to save data beyond the stack capacity secured by the task during task execution or dispatch, an overflow interrupt is generated by the stack overflow detection function, and the program immediately breaks. Even if the task in the execution state is changed by the dispatch, the stack overflow detection address of the execution state task is set to SOR1 each time, so that the stack overflow of each task can be detected.

If the system stack overflows during the processing of the system call or the execution of the interrupt program, the overflow interrupt occurs and the program immediately breaks because the SOR1 is set to the stack overflow detection address for the system. I do. Even if the stack overflow detection address changes due to the modification of the program in the debugging process, the stack overflow detection address is under the control of the OS, so that the user does not need to reset the address at the time of debugging.

As described above, according to the second embodiment, even in a multitask program, unlike the stack overflow detection by the hardware break function of the debugger, the debugger setting when using the detection function is not required. Even when a break condition (here, a stack overflow detection address) is changed due to frequent program modification at the time of debugging, it is not necessary to update the break condition, and an effect that a break before execution of an instruction is possible is obtained.

Embodiment 3 FIG. 3 is a diagram showing a state when a stack underflow occurs. FIG. 3A shows the state of the stack in the memory space 12 immediately after the execution of the subroutine or the interrupt program. Thereafter, the stack operation instruction is executed, and the stack state when the stack pointer address is reduced is as shown in FIG.
Then, when the subroutine ends or the interrupt program ends, if the stack pointer address is restored, the original saved data is restored, and the program continues to operate normally thereafter. However, if the stack pointer address is not restored, the saved data is restored from the reduced address, and eventually the stack is restored beyond the stack pointer address immediately before execution of the subroutine or interrupt program. Figure 3
It is shown in (c). Since the return data in this case is different from the original save data, the subsequent execution of the program may operate improperly. The stack underflow detection method according to the third embodiment prevents such a situation.

FIG. 4 is an explanatory diagram of a stack underflow detection method according to Embodiment 3 of the present invention. In FIG. 4, reference numeral 13 denotes a stack underflow register (hereinafter, SUR and SUR) as a first register in which a stack underflow detection address which underflows when data is excessively returned from the stack in a program initialization stage is set. ). Numeral 14 denotes a second in which the stack pointer address is set in the initial setting stage of the program.
Stack pointer register as a register of
SPR). Since the program uses a subroutine and an interrupt function, the setting of the stack pointer address is performed at the initial setting stage of the program.

Reference numeral 15 denotes when the program is executed,
This is a comparator that compares a stack underflow detection address with a stack pointer address and generates an interrupt request when the addresses match. Reference numeral 16 denotes an arbitrary register, in which an underflow interrupt enable bit 16a is set. That is, the interrupt enable bit for the underflow interrupt is enabled in order to enable the underflow interrupt immediately after the initialization and immediately before the execution of the main program.

Here, since this preparation processing is performed only on the microcomputer side, the stack underflow detection function cannot be used alone. In other words, the processing of the debugger must also be linked with the underflow interrupt of the microcomputer. The debugger sets the start address 18a of the break processing in the underflow interrupt vector area 18 of the ROM area 17 immediately before the execution of the program so that the debugger can perform the break processing when an underflow interrupt occurs for the interlocking.

Next, the operation will be described. Each time the microcomputer executes an instruction, the stack pointer address to be output at that time and the stack underflow detection address are compared by the comparator 15 inside the microcomputer.

If the stack is to be restored beyond the stack pointer address immediately before the execution of the subroutine or interrupt program, the comparator 15 compares the stack pointer address at that time with the stack underflow detection address. Will be. At this time, an interrupt request is generated for the first time. This interrupt accepts a request immediately like a reset. Using this request, the debugger breaks the program and performs processing after the break.

Here, even if the stack underflow detection address changes due to the program being modified in the debugging process, if a label is assigned to the stack underflow detection address on the program and the SUR13 is set by the label, the user There is no need to reset when debugging.

As described above, according to the third embodiment, unlike the detection of the stack underflow by the hardware break function of the debugger, it is not necessary to set the debugger when using the detection function, and the debugging is frequently performed. Even when a break condition (here, a stack underflow detection address) is changed due to program correction, the break condition need not be updated, and an effect that a break before execution of an instruction is possible is obtained.

Embodiment 4 FIG. Embodiment 4 of the present invention
The present invention is applied to detection of a stack underflow of a user stack of each task of a multitask program. The schematic circuit configuration in that case is similar to that of FIG. 4, but is not realized by the current OS function. FIG. 5 shows an additional configuration of the OS to be realized.

As shown in FIG. 5, resource information managed by the OS is stored in the system storage area 19 of the OS. To realize this function, the stack underflow detection address of the stack of each task is stored. Additional registration is performed as new management information, and a stack underflow detection address storage area 20 is provided. The address for detecting a stack underflow may be placed in the task control block.

The stack underflow detection address storage area 20 includes a system stack underflow detection address 21, a task stack underflow detection address 22 of ID1, a task stack underflow detection address 23 of ID2, and the like.

Further, as a function of the OS, the stack underflow detection address of the task to be executed next at the time of dispatch is read from the stack underflow detection address storage area 20 and set in the SUR 13. When the system stack is used during the execution of the OS process or the execution of the interrupt program, the system stack underflow detection address 21 is set in the SUR 13 before the execution of the process.

Next, the operation will be described. If an attempt is made to return data beyond the stack bottom (the largest address in the stack area) of the task during execution of the task, an underflow interrupt is generated by the stack underflow detection function, and the program immediately breaks. Even when the task in the execution state is changed by the dispatch, the stack underflow detection address of the execution state task is set in the SUR 13 each time, so that the stack underflow of each task can be detected.

Also, when an underflow of the system stack occurs during the execution of the OS process or immediately after the end of the interrupt program, the SUR 13 is set to the stack underflow detection address for the system. Break immediately. Even if the stack underflow detection address changes due to the program being modified in the debugging process, the stack underflow detection address is under the control of the OS, so that the user does not need to reset the address at the time of debugging.

As described above, according to the fourth embodiment, unlike the stack underflow detection by the hardware break function of the debugger, the debugger setting when using the detection function is unnecessary even in the multitask program. Also, when the break conditions (here, the stack underflow detection address) are changed due to frequent program modification at the time of debugging, the break conditions need not be updated, and a break before instruction execution is possible. Can be

[0040]

As described above, according to the present invention, a stack overflow detection address that overflows when data is excessively saved on the stack at the initial setting stage of a program is set in the first register, At the initial setting stage of the program, the stack pointer address is set in the second register, and immediately before the execution of the program, the start address of the break processing is set in the interrupt vector area,
When the program is executed, if the stack overflow detection address of the first register is compared with the stack pointer address of the second register and they match, an interrupt request is generated, and the debugger uses the start address of the break processing to execute the interrupt request. Since the break processing is configured to be executed, the debugger setting when using the detection function is unnecessary, and even when the break condition is changed due to frequent program modification during debugging, the break condition does not need to be updated. Further, there is an effect that a break before execution of an instruction can be performed.

According to the present invention, the stack overflow detection address of each task is set in the second register in the system storage area of the operating system.
Since the stack overflow detection address of the task to be executed next at the time of dispatch is read from the system storage area and set in the first register, the debugger setting when using the detection function is unnecessary even in the multitask program. In addition, when the break condition is changed due to frequent program modification at the time of debugging, it is not necessary to update the break condition, and it is possible to perform a break before executing an instruction.

According to the present invention, a stack underflow detection address which underflows when data is excessively returned from the stack at the initial setting stage of the program is set in the first register, and the program is initialized. Sets the stack pointer address in the second register, sets the start address of break processing in the interrupt vector area immediately before execution of the program, and sets the stack underflow detection address of the first register to the stack underflow address when the program is executed. If the stack pointer address of the second register is compared with and matches, an interrupt request is generated and the debugger is configured to execute the break processing using the start address of the break processing. No setting required, and frequent programs for debugging Updating the even break conditions when there is a change in the break condition by positive is unnecessary, there is an effect that it is possible to further break before execution of the instruction.

According to the present invention, the stack underflow detection address of each task is set in the system storage area of the operating system, and the stack underflow detection address of the task to be executed next at the time of dispatching is set from the system storage area. Since it is configured to read and set to the first register, it is not necessary to set the debugger when using the detection function even in a multitask program, and when the break condition is changed due to frequent program modification during debugging. Also, there is an effect that the break condition does not need to be updated, and a break before the execution of the instruction is possible.

[Brief description of the drawings]

FIG. 1 is an explanatory diagram of a stack overflow detection method according to a first embodiment of the present invention.

FIG. 2 is an explanatory diagram of a stack overflow detection method according to a second embodiment of the present invention.

FIG. 3 is a diagram showing a state when a stack underflow occurs.

FIG. 4 is an explanatory diagram of a stack underflow detection method according to a third embodiment of the present invention.

FIG. 5 is an explanatory diagram of a stack underflow detection method according to a fourth embodiment of the present invention.

FIG. 6 is a diagram illustrating a state when a stack overflow occurs.

[Explanation of symbols]

1 Stack overflow register (first register), 2 stack pointer register (second register), 6a break processing start address, 6b overflow interrupt vector area (interrupt vector area).

Claims (4)

[Claims] In a method for detecting a stack overflow of a debugger at the time of debugging an embedded program, a stack overflow detection address which overflows when data is excessively saved on a stack in an initial setting stage of a program is set in a first register. The stack pointer address is set in the second register in the initial setting stage of the program, the start address of the break processing is set in the interrupt vector area immediately before the program is executed, and the stack overflow detection is performed when the program is executed. The stack address is compared with the stack pointer address. If the stack overflow detection address matches the stack pointer address, an interrupt request is generated, and the debugger uses the start address of the break processing. Stack overflow detection method comprising a step of executing a break processing Te. 2. A stack overflow detection address of each task is set in a system storage area of an operating system, and a stack overflow detection address of a task to be executed next at the time of dispatch is read out from the system storage area to read the first stack overflow address. 2. The stack overflow detection method according to claim 1, wherein the stack overflow is set in the register. 3. A method for detecting a stack underflow of a debugger at the time of debugging an embedded program, wherein a stack underflow detection address which underflows when data is excessively returned from the stack in a program initialization stage is stored in a first register. The stack pointer address is set in the second register at the initial setting stage of the program, the start address of the break processing is set in the interrupt vector area immediately before the execution of the program, and when the program is executed, The stack underflow detection address is compared with the stack pointer address, and when the stack underflow detection address matches the stack pointer address, an interrupt request is generated, and the debugger sets the start address of the break processing. Stack underflow detection method which includes a step of executing a break processing I. 4. A stack underflow detection address of each task is set in a system storage area of an operating system, and a stack underflow detection address of a task to be executed next at the time of dispatch is read from the system storage area. 4. The method according to claim 3, wherein the first register is set.