JPH0465729A - Symbolic debugger - Google Patents

Abstract

PURPOSE:To trace the execution process of a program with a C language level by specifying a trigger point and a trace area in a target program at the time of debugging a kernel by means of a kernel symbolic C source debugger(KDB). CONSTITUTION:The KDB is started by a host debugging machine 20 to specify a trigger point and a trace area in a target program. The program is executed at every instruction by using a trace function based upon a hardware debugger 13, and at the time of confirming the passage of the program through the trigger point, the value of a program counter is stored in the trace area of a ring bugger in a work RAM 14. The stored program counter value is transmitted to the machine 20 and converted into a program source code by a C language and a traced result is displayed on the display of a monitor 30. Thus, the program can be traced by the C language level.

Description

[Detailed description of the invention]

<Industrial Application Field> The present invention relates to a symbolic debugger, and more particularly to a function of tracing the execution process of a target program in a kernel symbolic C source debugger. <Prior Art> For example, the present invention is used as a debugging system for debugging a kernel written in C language in UNIX (an operating system developed and licensed by AT&T Bell Laboratories in the United States.UNIX is a registered trademark). A debugger (kernel symbolic C source debugger 2 hereinafter referred to as KDB) that has a symbolic debugging function capable of debugging the kernel at the C language level, such as Japanese Patent Application No. 1-2884524 R Debug System filed by the applicant, is ). UN written in C language using such KDB
When debugging a kernel such as IX, you can set breakpoints at specific addresses in the target program and temporarily stop program execution at each point to check the internal state of the microprocessor, memory, and even the contents of the program. A commonly used method was to perform debugging while referring to variables. On the other hand, when debugging, if you want to trace the program execution process and check the process in which the target program has operated, KDB itself does not have such a function, so you can use an ICE (in-circuit emulator). I had no choice but to debug using software such as a computer or a logic analyzer. <Problems to be solved by the invention> However, ICE and logic analyzers themselves
Not only is the system very expensive, but it also has the problem of not being able to perform program tracing at the C language level. Additionally, depending on the type of microprocessor, ICE may not support it, or if the target hardware has a high operating frequency.
There was also the problem that the CE could not be used normally due to operational delays. The purpose of the present invention has been made in view of the above points. When debugging a UNIX kernel using KDB, the user wants to obtain a trace in a target program (hereinafter referred to as a trigger point). ), or the location where you want to obtain trace results (hereinafter referred to as the trace area), by specifying the location before and after the trigger point, or just before or after the trigger point, respectively, to trace the execution process of the target program at the C language level. The object of the present invention is to provide a symbolic debugger with functions that enable the following. Means for Solving the Problems> To achieve such objects, the present invention comprises a microprocessor having a trace interrupt function, a ROM equipped with a hardware debugger, and a ROM for storing program execution processes. The CPU board is connected via a communication line, and is composed of a ring buffer and a controller that performs the necessary controls for controlling the monitor and communicating with external machines. is a host program that allows you to specify trigger points and trace areas in a target program at the C language level.
Equipped with a debug machine, ■When executing the target program, the program is executed one instruction at a time using the hardware debugger or the trace function of the microprocessor, and the value of the program counter at that time is stored in the ring buffer. ■When it is confirmed that the program passes the trigger point, the value of the program counter is saved in the ring buffer by the trace area, and ■When the trace result is to be referenced, it is saved in the ring buffer. The host debug machine extracts the value of the program counter that has been sent and sends the data to the host debug machine via the RS-232C line. ■The host debug machine reads the data in C language based on the transmitted program counter value information. It is characterized by converting it into program source code and displaying the trace results on a monitor. Effect> In the present invention, a trigger point and a trace area in a target program are specified. Further, the program is executed one instruction at a time using the trace function of the hardware debugger, and the value of the program counter at that time is saved in the ring buffer. When it is confirmed that the program passes the trigger point, the value of the program counter is then stored in the trace area in the ring buffer. The program counter value thus saved is transmitted to the host debug machine via the communication line. The host debug machine converts the program source code in C language and displays the trace results on the display. <Example> The present invention will be described in detail below with reference to the drawings. Hereinafter, we will take as an example a case where Motorola's MC680XO (X is any numerical value of an existing model name) is used as a microprocessor having a trace interrupt function. FIG. 1 is a block diagram showing the basic system of the symbolic debugger of the present invention. In FIG.
The board 20 is a host debug machine that is connected to the CPU board via an RS-232C line and runs KDB.
30 is a monitor. In the CPU board 10, 11 is a microprocessor (MC680XO) having a trace interrupt function;
2 is a clock generator that generates a reference clock to be given to the processor 1; 13 is a ROM in which a hardware debugger is installed; 14 is a debugger work RAM for storing trace results; and 15 is a debugger monitoring device. A controller (for example, MC6850) that performs control and communication with the KDB, and 16 are other hardware. Trace data storage buffer in work RAM 14 (
(not shown) has a ring buffer structure in which the buffer address pointer (pointer indicating the address within the buffer for storing the program counter) is controlled by software, as shown in Figure 2. ing. In other words, the end point of the actual buffer can be viewed as if it were chained to the beginning point by the buffer address pointer. This allows a data storage buffer, which actually has a fixed size, to be configured so that there is no logical final point. Furthermore, the ring buffer can store the value of the program counter when the target program is executed, so each execution of one assembler instruction stores a 32-bit value (24 bits for the MC68000), or 4 bytes of address data. can be saved in a buffer. Figure 3 shows the configuration of the status register of MC68030. The status register has a 16-bit configuration, and bits 15 and 14 are called trace enable bits, and the target program is executed depending on the status of these two bits. When this happens, trace exception handling is performed and an interrupt is generated. In other words, in order to realize the trace function, the CPU board 1 must be installed in advance before executing the target program.
All you have to do is set these bits in the hardware debugger 13 in 0, and when an interrupt occurs, take out the program counter value from the stack frame and store it in the ring buffer, one instruction at a time. To refer to the results, read the program counter value in the ring buffer, send it to the host debug machine 20 via the RS-232C line, and send it to the KDB.
By converting the program counter information into a C language source code, it becomes possible to trace the execution process of the target program. Next, a method of storing the value of the program counter in the ring buffer during interrupt processing of the hardware debugger will be described. First, the user starts KDB using the host debugging machine 20 and specifies the part of the target program from which trace information is to be obtained as a trigger point using a line number in the C language source code. In addition, the area in which you want to obtain trace information including the trigger point is designated as a trace area. The trace area is the area before and after the trigger point.
), immediately before, and immediately after. The hardware debugger receives these parameters, sets a trace enable bit in the status register, and causes trace exception processing to occur when the target program executes one instruction. When the target program is then executed, a trace exception interrupt occurs every time one instruction is executed, and during interrupt processing, the program counter value is extracted from the trace exception stack frame and stored in the ring buffer. At this time, the buffer address pointer is updated every time the program counter is stored in the ring buffer, and if the pointer reaches the end of the buffer, the value of the next pointer is set as the beginning of the buffer. Also, the value of the program counter taken out at this time is compared with the value of the set trigger point. If the value of the program counter taken out during interrupt processing is equal to the value of the set trigger point, it is determined whether the value of the program counter is to be stored in the ring buffer according to the information of the set trace area. In other words, if the about specification is specified, then the value of the program counter is saved by half the physical size of the ring buffer, if the before specification is specified, saving of the program counter is immediately finished, and if the after specification is specified, the value of the program counter is then saved by the physical size of the ring buffer. Save the value. Then trace enable status register
Clear the bit and re-execute the target program without any trace exception interrupts. To refer to the trace results, retrieve the saved program counter value from the ring buffer and send it to the RS
The data is sent via the -232C line to the host debug machine 20 on which KDB is operating, and converted into C language source code by KDB based on the program counter information. The trace results are displayed on the display of monitor 30. In the above manner, the execution process of the target program can be traced. Next, a method for tracing the execution process of a target program according to the present invention will be explained using the flowcharts shown in FIGS. 4 to 6. FIG. 4 shows the processing when setting this function, and FIG. 5 shows the obtained trace results. FIG. 6 is a flowchart showing the operation of the hardware debugger when a trace interrupt occurs.

[Trace function setting (FIG. 4)] Processing of (1) and (2) The KDB of the host/debug machine 20 requests the user to specify the trigger point and trace area. The trigger point is the line number of the source code in C language, and the trace area is about, before, af
This is done by specifying ter. ① and ② Processing Using the hardware debugger, save the trigger point and trace area information specified in KDB to the work area. At this time, the trace area information is converted into a buffer pointer indicating how many steps of trace results are to be saved after the target program passes the trigger point. Process (2) Clear the flag indicating that the target program has passed the trigger point (trigger point passing flag). ② Set the trace enable bit in the status register in the processing microprocessor. As a result, when the target program is executed one instruction at a time, a trace exception interrupt occurs.

[Displaying trace results (FIG. 5)] Processing in (2) The KDB requests the hardware debugger to send the trace results. The program counter information, which is the trace result in the processing ring buffer of (2), is transmitted via the RS-232C line to the host debug machine 20 on which the KDB is operating. Based on the trace results obtained from the processing of (1) and (2), a corresponding location is searched on the source code in C language, and the result is displayed on the monitor 30.

[Trace interrupt (FIG. 6)] The value of the program counter loaded in the stack frame for process trace exceptions of (1) and (2) is taken out and saved in the area of the ring buffer pointed to by the buffer pointer. (2) Update the value of the processing buffer address pointer. At this time,
If the pointer value is the end of the actual buffer, the next pointer value is the beginning of the actual buffer. Compare the program counter value retrieved from the processing trace exception stack frame in (2) with the value of the set trigger point. If they are equal, proceed to the next process (2), and if they are not equal, proceed to process (2). Processing in (2) Since the target program has passed the trigger point, set the trigger point passing flag. As a result, after the next determination process (2), the process (2) is executed. Check whether the target program has passed the set trigger point by referring to the processing trigger point passing flag in (2). If it has passed, the process moves to ■, and if it has not passed, it moves to process ■. ② Set the trace enable bit in the processing status register and return from exception processing. This causes the trace exception interrupt to occur again when the target program executes the next instruction. (2) Determine whether the value of the processing buffer pointer is 0 or not. If it is O, the process moves on to finish saving the program counter value in the ring buffer. If it is not 0, the process moves to process (2). Set the trace enable bit in the processing status register (2) so that the next trace exception interrupt will occur when the target program is executed for one more instruction. Subtract 1 from the value of the processing buffer pointer in (2). Clear the trace enable bit in the processing status register to prevent trace exception interrupts from occurring. According to the above embodiment, the trace result of the target program can be specified in three types according to the information of the specified trace area: before and after the trigger point, immediately before the trigger point, and immediately after the trigger point. If this is further developed, the following functions can also be made possible. ■When specifying the trace area from KDB, if you can specify a value indicating how many steps of trace results to save after the target program passes the trigger point, you can freely select the area that includes the trigger point. You can specify and get trace results. Therefore, the user can obtain the desired reliable trace results. ■When specifying a trigger point from KDB, if you can specify how many times the trigger point must be passed before saving the trace result, you can ensure that even if the target program passes the trigger point several times. Trace results can be obtained. Note that this Il function can be easily realized in software using a counter within a hardware debugger. <Effects of the Invention> As explained in detail above, by using the program tracing function according to the present invention, the execution process of a published program can be traced at the C language source code level, and the process of the target program can be traced. This allows you to debug while checking whether it is working properly. Therefore, it can be seen that the debugging system of the present invention dramatically improves the debugging efficiency compared to the conventional debugging system composed of a KDB and a hardware debugger having only the breakpoint Il function. Furthermore, since the debug function of the present invention is realized by a hardware debugger that is part of the firmware in the CPU board and a KDB that is software running on the host debug machine, even the memory for buffering the trace results is If so, it can be easily achieved. Therefore,
Compared to conventional methods of debugging using ICE or logic analyzers, this method allows easy debugging while tracing the target program in an inexpensive manner.

[BRIEF DESCRIPTION OF THE DRAWINGS] FIG. 1 is a configuration diagram showing an embodiment of a symbolic debugger according to the present invention, FIG. 2 is an explanatory diagram of the configuration of a ring buffer, and FIG. 3 is a diagram illustrating the configuration of a status register. 4 to 6 are flowcharts for explaining the operation. 10...CPU board, 11...Processor, 12
...Clock generator, 13...ROM, 14...
RAM, 15... Controller, 20... Host
Debug machine, 30...monitor. Figure 4, Figure S

Claims (1)

[Claims] A microprocessor having a trace interrupt function;
It consists of a ROM equipped with a hardware debugger, a ring buffer for storing the program execution process, and a controller that performs the necessary controls for controlling the monitor and communicating with external machines. A CPU board is connected to the CPU board via a communication line, and is equipped with a host debug machine that allows the user to specify trigger points and trace areas in the target program at the C language level. When executing a program, the hardware debugger executes the program one instruction at a time using the trace function of the microprocessor, and stores the value of the program counter at that time in the ring buffer; When it is confirmed that the trigger point has been passed, the value of the program counter is saved in the ring buffer by the trace area, and (3) when referring to the trace result, the value of the program counter saved in the ring buffer is saved. (4) The host debug machine converts the data into C language program source code based on the transmitted program counter value information. A symbolic debugger that converts and displays trace results on a monitor.