JP2591432B2 - Trace device - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a tracing device for debugging a program, and more particularly to a tracing device for tracing local variables.

[0002]

2. Description of the Related Art Normally, in a high-level language such as the C language, local variables involved only in processing a specific part of a program, for example, a subroutine or an interrupt routine, are allocated on a stack, and access to the local variables is performed by a specific register. This is performed by a register relative access instruction for.
This register is called a base pointer.

In some cases, a specific register is reserved as a base pointer exclusively for the base pointer. This will be described with reference to FIGS. 11, 12, and 13. FIG. FIGS. 11A and 11B are C language source programs, and FIGS. 12A and 12B are diagrams in which the hl register is assigned to the base pointer, and FIGS. FIG. 13B is an assemble list of an object after compiling the source program. FIG. 13A shows a case where a function y () is a function x when an hl register is assigned to a base pointer.
Shows the contents of the stack when called from (). That is, in FIGS. 12A and 12B, the base address of the local variable of each function is stored in the hl register serving as a base pointer, and access to the local variable is performed by register relative addressing using the hl register.

The address of a local variable shown in FIG. 13A is not uniquely determined, but changes according to the address of the top of the stack when the function is called. For example, even if the function y () is the same, the stack top address when it is called is 0FE08h shown in FIG. 13B and 0FE1h shown in FIG.
In the case of 0h, the addresses of the local variables c, d, e, f also differ by 8 bytes. The fact that the address of a local variable is not uniquely determined but changes is that, even if the address is the same, the local variable assigned to the address changes. For example, the local variable a of the function x () called when the stack top is 0FE04h shown in FIG. 13D and the stack top are 0FE08 shown in FIG.
The local variable e of the function y () called at the time of h is an address of 0FE02h.

In order to identify a local variable having the above-described properties, three traces of an address at the time of data access, a base address of the local variable at that time, and a program execution address at that time are required. For example, the address at the time of data access is [hl] in FIG.
+3], [hl + 2], [hl + 1], [hl], FIG.
[Hl + 7], [hl + 6]... [Hl] in FIG. 2B, and the base addresses of the local variables are hl in FIG. 12A and hl in FIG. In this case, since there is a common value between the two, the discrimination between the program of FIG. 12A and the program of FIG.
They are identified by value. In the case where the above three addresses are not traced, in accessing the local variables, if an attempt is made to identify which local variable has been accessed, it is necessary to perform time-consuming data processing on the trace data. No. That is, in order to obtain the program execution address at that time, the trace data must be traced back to check the fetch address immediately before the data access, and to obtain the base address of the local variable at that time, the trace data must also be obtained. It is necessary to check the value assigned to the h1 register, which is the base pointer, retroactively. Furthermore, when the trace memory is full due to the small capacity of the trace memory, the oldest trace data is overwritten with the latest trace data, so the trace data is erased and the identification of local variables Sometimes it becomes impossible at all. In addition, when qualifying trace or section trace is performed, these data may be excluded from the trace target and may not be recorded in the trace memory. It will be impossible.

For this reason, the applicant of the present application traces three addresses: the address at the time of data access, the base address of the local variable at that time, and the program execution address at that time when the base pointer is allocated to the hl register. 14 is proposed. FIG.
In the Eva chip of the microprocessor (Eva
trace chip) is traced to the trace memory 2. In FIG. 14, in order to trace the value of the hl register, a decoder 3, a NAND circuit 4, a base pointer latch circuit 5, and the like for identifying an internal register are provided.
That is, when writing to the internal register in the evaluation chip 1, the register address RA for identifying which internal register has been written and the written register data R
D, a register write signal RW for notifying that data has been written to the internal register is sent from the evaluation chip 1. In response, the decoder 3 sends a match signal to the NAND circuit 4 when the register address RA matches a register (here, the hl register) holding the base address of the local variable. The NAND circuit 4 also receives the * register write signal RW from the evaluation chip 1. As a result, the register data RD is latched by the base pointer latch 5 with the strobe signal STR1 created from the coincidence signal from the decoder 3 and the * register write signal RW. In FIG. 14, a program execution address latch circuit 6 is provided to trace the program execution address. That is, the contents of the address bus AB output from the evaluation chip 1 * read signal S ₁ and the instruction fetch / * data access status signal fetch strobe generated from S ₂ signal STR
In step 2, the program execution address latch 6 latches the program execution address.
The output of the base pointer latch circuit 5 and the output of the program execution address latch circuit 6 are input to the trace memory 2 and are supplied to the trace memory 2 together with the values of the address bus AB, the data bus DB, the * write signal S _3, etc.
It is written by ₁ and * write signal generated from S ₃ * tracer write signal TW.

FIG. 15 shows the contents of the trace memory 2 shown in FIG. 14. Only the information at the time of data access is shown in FIG. The address, data, status, base pointer value, and program execution address are recorded in the trace memory 2. FIG. 16 shows a table of debug information generated by the C compiler, which is written in advance in a memory (not shown). The table includes a function name, a function start address, and a function end address. Each function has a table of variable names, variable offsets, and variable sizes included in the function. FIG. 17 is a flowchart for identifying a local variable using the contents of the trace memory 2 shown in FIG. 15 and the debug information shown in FIG.
4 is executed by a microprocessor (not shown). First, in step 1701, it is determined whether or not the program execution address in the trace memory 2 is between the start address and the end address of the function, and the function that has performed data access is specified. Next, step 1
At 702, a variable offset is calculated by subtracting the value of the base pointer from the value of the address. Further, in step 1703, the local variable of the specified function is searched for a variable in which the calculated value of the variable offset falls within the range obtained by adding the variable size to the variable offset and the variable offset on the table. Determine the variables. Then, the routine in FIG. 17 ends in step 1704.

[0008]

However, in the above-described tracing device, the compiler generates an object that reserves a specific register, for example, the hl register exclusively for the base pointer.
Because of this assumption, such a compiler has a problem that a few internal registers are substantially reduced .

Some compilers use a base pointer
Object that uses the stack pointer as
You. When the stack pointer is also used as the base pointer , the following problem occurs. In other words, when a specific register is reserved exclusively for the base pointer, the part where the base pointer is saved and set at the entry of the subroutine (referred to as the prologue part) and the base pointer is restored at the exit of the subroutine. Except for the part (referred to as epilogue part), the value of the base pointer is constant in the subroutine. On the other hand, if the stack pointer is also used as the base pointer, the argument is pushed onto the stack when calling a subroutine, and the value of the stack pointer that should hold the base address of the local variable changes in this part. . This will be described in more detail with reference to FIGS.
(C) a particular register (hl) in the case of securing the base pointer only the source program to explain the difference between the case of shared stack pointer (sp) as a base pointer, 19, 20 (Corresponding to (A) in FIG. 18), FIG. 21 (corresponding to (B) in FIG. 18), and FIG. 22 (corresponding to (C) in FIG. 18) after compiling when the hl register is reserved exclusively for the base pointer. And the change of the values of sp and hl are written together in the assemble list of the object. Here, the values of sp and hl in FIGS. 21 and 22 are the values at the time of calling the subroutine at the place marked with * in FIG. As is apparent from these, the hl which is the base pointer only changes at the entry and exit of the subroutine, and is constant in the part where the local variable is actually accessed in the subroutine. Therefore, the same local variable is always accessed using the same relative offset in the subroutine. On the other hand, FIG. 23, FIG. 24 (corresponding to FIG. 18A), FIG. 25 (corresponding to FIG. 18B), and FIG.
Corresponding to 8 (C)) is obtained by also shown a change in sp value assembly list of objects of the compiled when was also used the stack pointer sp as a base pointer. Here, the stack pointer s shown in FIGS.
The value of p is the value at the time of calling the subroutine at the place marked * in FIG. As is apparent from the above description, the value of sp, which is the base pointer, pushes an argument to be passed to the subroutine onto the stack, and pops the stack to release an argument area when returning from the subroutine. It changes every time. As a result, to access the same local variable in a subroutine, it is accessed using different offsets of several. For example, in FIG. 23, three offsets of +3, +5, and +7 are used to access the local variable a. As described above, when the stack pointer is also used as the base pointer, the value of the stack pointer changes finely. Therefore, if the trace of the base pointer is simply traced, the stack pointer is required to analyze the trace result. The information of the offset of the local variable is required for each changing place, the amount of debug information increases, and the analysis takes time.

[0010]

According to the present invention, there is provided a trace apparatus for tracing the execution of an object program obtained by compiling a source program. It is incremented or decremented by the signal generated at the time,
An up / down counter that is decremented or incremented by a signal generated when the subroutine or interrupt routine of the object program returns, and a signal generated when the subroutine or interrupt routine of the object program is called are received as strobe signals and received from the address bus. A base pointer write memory that saves a stack pointer value as a base pointer value of a local variable of a source program to a storage location whose address is an up / down counter value, and a base pointer write memory that uses an up / down counter value as an address Object output as base pointer value
When the project program accesses data,
At least, base pointer value, program execution address
And a trace memory for tracing the accessed address . Further, the present invention inputs the address of the object program as the memory address, a base pointer determined value detection execution of the object program stack pointer value to the address that was established as a base pointer value to output a signal indicating that the Tsu optimum The memory includes a memory and a stack pointer latch circuit that latches the stack pointer value each time the stack pointer value is updated. In this case, the base pointer write memory receives the signal from the base pointer determined value detection memory as a strobe signal, and uses the stack pointer value from the stack pointer latch circuit as the base pointer value of the local variable of the source program, and Is saved to a storage location whose address is the value of.

[0011]

According to the above-mentioned means, without increasing debug information, the stack pointer of the object which also serves as the base pointer of the local variable of the source program can be used.
Even in such a case, local variables are efficiently identified .

[0012]

FIG. 1 is a block circuit diagram showing a first embodiment of a trace device according to the present invention. In FIG.
Instead of the fourteen decoders 3, the NAND circuit 4 , the base pointer latch circuit 5, etc., an up / down counter 7, an OR circuit 8, a base pointer write memory 9, etc. are provided to read the stack pointer sp from the address bus AB. is there. Except traces of the base pointer is the same as in FIG. 14. The up / down counter 7 is incremented by +1 by a signal * CALL / * INT when calling a subroutine or an interrupt routine, and decremented by 1 by a signal * RET / * IRET when returning from a subroutine or interrupt routine. You. The output value of the up / down counter 7 becomes an address of the base pointer write memory 9. The value of the stack pointer sp on the address bus AB is written into the base pointer write memory 9 by the OR circuit 8 when a subroutine or an interrupt routine is called and written.

The operation of the circuit of FIG. 1 will be described with reference to the timing chart of FIG. FIG. 2A is a timing chart when a subroutine is called and when it returns. That is, * C
The ALL / * INT status signal is at the 0 level from time t _{1 to} t ₃ from the start of the subroutine calling operation to the end of pushing the return address onto the stack. As a result, at time t ₁ , the up-down counter 7
Is incremented at the falling edge of the * CALL / * INT status signal, and the address of the base pointer write memory 9 is advanced to the first address. The subroutine call at time t ₂ ~t _3, although the write operation of the return address to memory for pushing the stack is performed, the base pointer write memory 9 removed * write signal when the by OR circuit 8 R /
* Supply to W terminal. As a result, the stack address sp output to the address bus AB is written to the base pointer write memory 9. The output of the base pointer write memory 9 is written to the trace memory 2 as a base pointer value. Although not shown, when a subroutine is further called in the subroutine, the address of the base pointer writing memory 9 further advances to the first address, and the base pointer value is written there. * RET / * IRET when returning from the subroutine
Status signal is, time t ₄ ~t ₅ from the start of the subroutine return operation until you pop the return address from the stack, is zero level. As a result, the up-down counter 7 at time t ₅ is, * RET / * IRET is counted down by the up-edge of the status signal returns the address of the base pointer write memory 9 after one address. Thus, the base pointer value before the subroutine is called is output from the output D _OUT of the base pointer write memory 9.

FIG. 2B is a timing chart at the time of calling the interrupt routine and at the time of returning from the interrupt routine. The operation is different from that of the subroutine of FIG. 2A. In the case of the interrupt routine, not only the return address but also the flag register is pushed on the stack, so that the * CALL / * INT status signal becomes 0.
The point is that the write operation to the memory is performed twice as shown by arrows X1 and X2 during the level. What is needed as the base pointer value is the address when the second write operation is performed, and the address when the first write operation is performed is unnecessary.
Are not changed, and the same address is overwritten. In this case, the stack address at the time of performing the first write operation is written in the trace memory 2, but this value is not used for identifying local variables, so there is no problem.

FIG. 3 is a block circuit diagram showing a second embodiment of the trace device according to the present invention. In the first embodiment of FIG. 1, the * CALL status signal or * I
This is the case where the NT status signal maintains the 0 level until the return address is pushed.
In the embodiment of *, * CALL signal or * INT
This is the case where the status signal maintains the 0 level only for a short time, and in this case, the same operation as in the first embodiment can be performed. Therefore, in FIG. 3, the components of FIG.
1 is added. Here, the counter 10 counts one zero-level pulse at the clock terminal CK after receiving the zero level of the * CALL signal at the trigger terminal Trg, and outputs a one-level pulse to the output terminal Q. Also,
The counter 11 outputs * INT signal 0 to the trigger terminal Trg.
After receiving the level, two 0-level pulses are counted to the clock terminal CK and a 1-level pulse is output to the output terminal Q.

Referring to the timing charts of FIGS. 4A and 4B corresponding to FIGS. 2A and 2B, * CALL indicates that a subroutine or an interrupt routine is being called. Status signal and * IN
The T status signal outputs the 0 level only at the start of the operation, and returns to the 1 level when the return address or the flag register is pushed onto the stack. For this reason, in FIG. 4A, the counter 10 indicates * CALL
After the status signal goes to the 0 level, the 0 level is output only while the first * write signal is at the 0 level. In FIG. 4B, after the * INT status signal goes to the 0 level, the counter 11 outputs the 0 level only during the period in which the second * write signal is at the 0 level. The OR circuit 8 functions to end the write operation to the base pointer write memory 9 without delay even when the outputs of the counters 10 and 11 are delayed. Also , as in the first embodiment of FIG. 1, the up / down counter 7 is set to * CALL.
The up-counting is performed at the down edge of the status signal or the * INT status signal, and the down-counting is performed at the down edge of the * RET status signal indicating the return from the subroutine or the * IRET status signal indicating the return from the interrupt routine. The operation of the base pointer write memory 9 is the same as in the first embodiment.

The contents of the trace memory 2 obtained in the above-described first and second embodiments have to be corrected by the debug information output by the compiler because the traced base pointer value is not a correct base pointer value. It is the same as the contents of FIG. 15 except that it is a value. Hereinafter, this correction method will be described using a C compiler as an example. The object output by the compiler is reduced in the prologue portion by the size for securing the stack pointer in order to secure an area for local variables. For example, in the case of the function r , as shown in FIG. 23, the stack pointer sp is reduced by 4 ( 4 bytes) in the prologue part, and in the case of the function p, as shown in FIG. 2
Times ( 2 bytes). Therefore, in order to correct the base pointer value, information on the stack size secured in the prologue part is necessary, and as shown in FIG. 5, the compiler outputs this information on the stack size as debug information. . That is, in FIG.
The difference from FIG. 16 is that the stack size secured in the prologue portion is output for each function.

FIG. 6 is a flowchart for identifying a local variable using the contents of the trace memory 2 shown in FIG. 1 or FIG. 3 and the debug information shown in FIG.
3 is executed by a microprocessor (not shown). In FIG. 6, step 601 is added to the flowchart of FIG. That is, before calculating the variable offset in step 1702, in step 601, a function is searched from the traced program execution address, and the secured stack size of the function is subtracted from the traced base pointer value to correct the function. Calculate the base pointer value. Thereafter, in steps 1702 and 1703, a local variable is identified from the base pointer value as in FIG.

FIG. 7 shows a third example of the tracing device according to the present invention.
FIG. 2 is a block circuit diagram showing an embodiment of the present invention. In FIG. 7, a base pointer reserved value detection memory 12 and a stack pointer latch circuit 13 for outputting that the stack pointer value is determined as the base pointer value are added to the components of FIG. In the evaluation chip 1, when a write operation to the stack pointer sp is performed, write data to the stack pointer sp is output as stack pointer data. At the same time, a stack pointer write signal indicating that writing has been performed on the stack pointer is output. As a result, the stack pointer data is latched by the stack pointer latch circuit 13. On the other hand, the base pointer fixed value detection memory 12
Have the same address space as the program memory and are connected to the same address bus as the program memory.
It is a bit-width memory. When the debug target program is loaded into the program memory, the base pointer reserved value detection memory 12 is passed through the prologue of each subroutine of the debug target program (FIG. 23,
1 is written in the address (indicated by ◎ in FIGS. 25 and 26), and 0 is written in all other portions. Since the base pointer fixed value detection memory 12 is connected to the same address as the program memory, the output which has been 0 changes to 1 when the execution of the debug target program exits the prologue. This output is input to the R / * W terminal of the base pointer write memory 9 after removing the dullness of the waveform by the NAND circuit 8 ', and the output of the stack pointer latch circuit 13 is written to the base pointer write memory 9.

FIG. 8 shows the circuit operation of FIG. 7 when the subroutine is called and when it returns. In FIG. 8, time t ₁ : CALL instruction fetch t ₂ : push of return address t ₃ : instruction fetch of prologue part t ₄ : instruction fetch of prologue part t ₅ : instruction fetch of prologue part (write operation to stack pointer) There) t _6: prolog first instruction fetch after exiting the t _7: RET instruction fetch t _8: return address popped Further, the circuit operation of FIG. 7 in the case when the calling time and the return of the interrupt routine 9 Is shown in In FIG. 9, time t ₁ : push of flag register t ₂ : push of return address t ₃ : instruction fetch of prologue part t ₄ : instruction fetch of prologue part t ₅ : instruction fetch of prologue part (write to stack pointer) operation There) t _6: the first instruction after exiting the prolog fetch t _7: RET instruction fetch t _8: return address popped t _9: a pop flag register.

In the third embodiment shown in FIG. 7, the address at the end of the prolog is required. As shown in FIG. 10, the end address of the prolog is a subroutine (a function in the C language) used by the compiler as debug information.
Output every time. This prologue end address is set in the base pointer fixed value detection memory 12. Also,
The operation of the up / down counter 7 and the operation of the base pointer write memory 9 saving / restoring the base pointer value are the same as those in the first and second embodiments. Also, the method of identifying a local variable from the trace data does not require correction of the traced base pointer value, and thus is performed according to the flowchart of FIG.
Unlike the first and second embodiments, the compiler does not need to output the stack size secured in the prologue as debug information.

In the above embodiment, the up / down counter 7 counts up by the * CALL / * INT signal and counts down by the * RET / * INT signal, but counts down by the * CALL / * INT signal. Alternatively, the count may be increased by the * RET / * IRET signal.

[0023]

As described above, according to the present invention, an object program obtained by compiling a source program is an object program using a stack pointer as a base pointer of a local variable of the source program. , Local variables can be efficiently identified with less debug information.

[Brief description of the drawings]

FIG. 1 is a block circuit diagram showing a first embodiment of a trace device according to the present invention.

FIG. 2 is a timing chart for explaining the operation of the circuit in FIG. 1;

FIG. 3 is a block circuit diagram showing a second embodiment of the trace device according to the present invention.

FIG. 4 is a timing chart illustrating the operation of the circuit in FIG. 3;

FIG. 5 is a table diagram showing debug information in FIGS. 1 and 3;

FIG. 6 is a flowchart for identifying local variables in FIGS. 1 and 3;

FIG. 7 is a block circuit diagram showing a third embodiment of the trace device according to the present invention.

FIG. 8 is a timing chart for explaining the operation of the circuit in FIG. 7;

FIG. 9 is a timing chart for explaining the operation of the circuit in FIG. 7;

FIG. 10 is a table showing debug information in FIG. 7;

FIG. 11 is a program list showing an example of a C language source program.

FIG. 12 is an assemble list after compiling the source program of FIG. 11 ;

FIG. 13 is a diagram illustrating an example of allocation of local variables on a stack.

FIG. 14 is a block circuit diagram showing the previously proposed trace device.

FIG. 15 is a table showing the contents of a trace memory shown in FIG. 14;

FIG. 16 is a table showing debug information in FIG. 14;

FIG. 17 is a flowchart for identifying a local variable in FIG. 14;

FIG. 18 is a program list showing an example of a source program for explaining a problem.

FIG. 19 shows an hl register as a base pointer,
7A is an assemble list after compiling the source program of FIG.

FIG. 20 shows a state where the hl register is used as a base pointer.
7A is an assemble list after compiling the source program of FIG.

FIG. 21 shows a case where the hl register is used as a base pointer and FIG.
7B is an assemble list after compiling the source program of FIG.

FIG. 22 shows a state where the hl register is used as a base pointer.
7C is an assemble list after compiling the source program of FIG.

FIG. 23 is an assemble list after compiling the source program of FIG. 18A using the stack pointer as a base pointer.

FIG. 24 is an assemble list obtained by compiling the source program of FIG. 18A using a stack pointer as a base pointer.

FIG. 25 is an assemble list after compiling the source program of FIG. 18B using the stack pointer as a base pointer.

FIG. 26 is an assemble list after compiling the source program of FIG. 18C using the stack pointer as a base pointer.

[Explanation of symbols]

 DESCRIPTION OF SYMBOLS 1 ... Evaluation chip 2 ... Trace memory 3 ... Decoder 5 ... Base pointer latch circuit 6 ... Program execution address latch circuit 7 ... Up / down counter 9 ... Base pointer write memory 10, 11 ... Counter 12 ... Base pointer fixed value detection memory 13 ... Stack pointer latch circuit AB ... Address bus DB ... Data bus STR1, STR2 ... Strobe signal

Claims (4)

(57) [Claims] 1. A tracing device for tracing the execution of an object program obtained by compiling a source program, wherein a signal (* CALL) generated when a subroutine or an interrupt routine of the object program is called.
/ * INT signal), an up / down counter (7) which is incremented or decremented by a signal (* RET / * IRET signal) generated when returning from the subroutine or interrupt routine of the object program.
Receiving the signal generated at the time of calling the subroutine or interrupt routine of the object program as a strobe signal (STR1), and
A base pointer write memory (9) for saving the stack pointer (sp) value from B) as a base pointer value of a local variable of the source program to a storage location having the address of the up / down counter as an address; The object program uses the output of the base pointer write memory (9) having the address of the counter as an address as a base pointer value to execute data access.
At least the base pointer
Value, program execution address and accessed address
Traces apparatus characterized by comprising a trace memory (2) to trace. 2. A means for inputting a program execution address of the execution of the object program into the trace memory, and a debug information table previously output as debug information by a compiler using the program execution address in the trace memory. Means for determining a subroutine or an interrupt routine, and a base pointer value input to the trace memory,
Means for correcting using the reserved stack size of each subroutine or interrupt routine previously output as debug information by the compiler, and local variables of the source program from the corrected base pointer value and the address recorded in the trace memory. 2. The tracing apparatus according to claim 1 , further comprising: means for calculating a variable offset of: and means for determining a local variable in the determined subroutine or interrupt routine using the variable offset. 3. A tracing device for tracing execution of an object program obtained by compiling a source program, wherein a signal (* CALL) generated when a subroutine or an interrupt routine of the object program is called.
/ * INT signal), an up / down counter (7) which is incremented or decremented by a signal (* RET / * IRET signal) generated when returning from the subroutine or interrupt routine of the object program.
And a program execution address of the object program
Is input as a memory address, and the object pointer is reached until the address at which the stack pointer
A base pointer definite value detection memory for executing the object program to output a signal indicating that the Tsu Itaru (12), the stack pointer latch circuit for latching the stack pointer value each time the stack pointer value is updated (13)
Receiving a signal from the base pointer fixed value detection memory as a strobe signal (STR1), and updating the stack pointer value from the stack pointer latch circuit (13) as a base pointer value of a local variable of the source program. a memory for the base pointer write to save the value of the down counter in a memory location whose address (9), as the base pointer value output of the up-down counter memory for the base pointer write to the value as the address (9), wherein If the object program
At least the base pointer
Value, program execution address and accessed address
Traces apparatus characterized by comprising a trace memory (2) to trace. 4. A means for inputting a program execution address of the execution of the object program into the trace memory, a debug information table previously output as debug information by a compiler using the program execution address in the trace memory. Means for judging a subroutine or an interrupt routine, means for calculating a variable offset of a local variable of the source program from the base pointer value and an address recorded in the trace memory, and the judgment using the variable offset. 4. A tracing device according to claim 3 , further comprising: means for determining a local variable in the executed subroutine or interrupt routine.