KR100428712B1 - A Tracepoint Setting Method for Non-Stop Debugging of Multi-task Programs - Google Patents

Abstract

The present invention relates to a method for setting a tracepoint for non-stop debugging of a multi-task program. The present invention relates to a method for setting a monitoring tracepoint at an instruction level in real-time software development, thereby making it easy to find bugs that occur during real-time execution. Trace point setting method for non-stop debugging of a task program and a trace point setting method applied to a debugging system for debugging a multitask program to provide a computer-readable recording medium on which a program for realizing the method is implemented. In the tray, receiving a trace command (Command) for setting the trace point and the execution of the application program to be monitored, the tray for executing the received trace command Step execution command; A tracepoint setting step of setting a tracepoint by inserting an 'undefined-exception code' into the application program according to the execution of the trace instruction; A trace function execution step of executing a user-defined trace function according to generation of a trap at the trace point during the execution of the application program setting the trace point; And a trace message outputting step of outputting a trace message obtained by executing the user trace function, and used for information development software development.

Description

A tracepoint setting method for non-stop debugging of multi-task programs}

The present invention relates to a method for setting a tracepoint of a multitask program, and in particular, in real-time software development, it is possible to set a monitoring tracepoint at an instruction level so that bugs occurring during real-time execution can be easily found. The present invention relates to a method for setting a tracepoint for non-stop debugging of a multi-task program, and a computer-readable recording medium having recorded thereon a program for realizing the method.

In general, the embedded real-time software development for information appliances has a target and target board (14) by producing an information appliance system object code (13) having an editing and compilation environment and a debugging and monitoring environment (10) on the host computer (11, 12). You can download and run it on your server and monitor it and debug it.

In order to provide an effective test environment and debugging environment under such a remote development environment, a test program can be downloaded and executed on a target on a host computer and debugged, as well as a continuous signal in real time from a working environment like hardware debugging. It is important to provide an environment for input, collection and analysis of it.

Using monitoring tracepoints to monitor signals on hardware chips is the basic task of hardware debugging. Collecting signals in real time continuously from the work environment and viewing them visually will provide the basis for understanding the behavior of the system. Currently, observing variable signal changes by changing input values at trace points using tools such as a logic analyzer to determine the performance of this hardware when a hardware electronic board is present is an important task of hardware debugging. Is considered.

As with hardware debugging, it is important to implement real-time applications using monitoring tracepoints when debugging software in remote development environments. However, conventional techniques in the field of software use either a very simple way to track a program by inserting and executing a "printf" statement directly at the point of trace, or by using a resource monitor in a more advanced way. In order to track the execution status of a program that occurs in real time, a method using monitoring API (Application Program Interface) functions is used at a trace point.

However, the method of inserting the "printf" statement directly into the application program or executing the tracepoint using special monitoring API code has to be performed by directly inserting the test code into the source-code. There is a risk of breaking the purity of the original source code, and there is a problem in that in all cases to test, there is an inefficiency to write a test program by changing the source code corresponding to the number.

A method of simplifying the creation, testing, and debugging of such a cumbersome test program so that it can be efficiently executed is strongly required in order to increase productivity of software development.

The present invention has been proposed to meet the above demands. In the real-time software development, it is possible to set a monitoring trace point at the instruction level, thereby making it easier to find bugs occurring during real-time execution. It is an object of the present invention to provide a method for setting a tracepoint for debugging and a computer-readable recording medium recording a program for realizing the method.

That is, the present invention can execute a program while loading / unloading an application program to a target and user commands for enabling / disabling an instruction level trace point in a host computer. Built-in user-defined trace functions and the execution of tracepoint instructions that are performed with a real-time operating system (RTOS) kernel on the target. By building a triggering system for real-time software for information appliances, as in hardware development at the instruction level, monitoring tracepoints can be directly set and executed in the target application program on the host computer during real-time execution. To understand the behavior of the system To, to provide a method for the trace points set in the non-stop debugging multitask programs and a computer-readable recording medium recording a program for realizing the above method it is an object.

1 is an explanatory diagram of a multitask remote tracepoint debugging environment in accordance with the present invention;

2A is an embodiment configuration diagram of a software function block for tracepoint debugging in accordance with the present invention.

2B is a flow diagram of an embodiment of a method for setting a tracepoint for non-stop debugging of a multitasking program in accordance with the present invention.

3 is a flow diagram of one embodiment of a trace instruction input processing method in accordance with the present invention;

4 is a flow diagram of an embodiment of a trace message output method according to the present invention;

5 is a flow diagram of one embodiment of a method for processing an info trace command in accordance with the present invention.

6 is a flowchart illustrating an embodiment of a method for processing a trace instruction according to the present invention.

7 is a flow diagram of one embodiment of a method for processing a traceDelete command in accordance with the present invention.

8 is a flow diagram of one embodiment of a method for processing a traceMap command in accordance with the present invention.

9 is a flow diagram of one embodiment of a method for processing a traceUnMap instruction in accordance with the present invention.

10 is a flowchart illustrating an embodiment of a method for processing a local variable view command according to the present invention.

11 is a flowchart illustrating an embodiment of a method for processing a global variable command in accordance with the present invention.

12 is a flow diagram of an embodiment of a method for processing a TracePointAdd in a target according to the present invention.

13 is a flow diagram of an embodiment of a method for processing a TracePointDelete in a target according to the present invention.

14 is a flowchart illustrating an exemplary method of processing a trigger in a target according to the present invention. * Explanation of symbols for main parts of the drawing 20: Trace command input unit 21: Trace message output unit 22: Hard disk 23: Trace Point Debugging Engine 24: Host Debugging Agent 25: User Trace Function 26: Application Program 27: Target Debugging Command Processing Unit 28: Trace Point Add / Remove Unit 29: Trace Triggering Processing Unit

In the method of the present invention for achieving the above object, in a trace point setting method applied to a debugging system for debugging a multi-task program, a trace command for setting a trace point from a user and executing an application program to be monitored A trace command execution step of receiving a command and executing the received trace command; A tracepoint setting step of setting a tracepoint by inserting an 'undefined-exception code' into the application program according to the execution of the trace instruction; A trace function execution step of executing a user-defined trace function according to generation of a trap at the trace point during the execution of the application program setting the trace point; And a trace message outputting step of outputting a trace message obtained by executing the user trace function. The method of the present invention may further include a trace command for adding a trace point input from the user. The method may further include a trace point additional setting step of additionally setting a trace point in the application program according to the execution. The method of the present invention may further include the step of performing a trace command for deleting a trace point received from the user. The method may further include a trace point deleting step of deleting the trace point set in the application program according to the execution.

On the other hand, the present invention, in order to set the trace point for the non-stop debugging of the multi-task program, input a trace command (Command) for executing the application program to be set the trace point and the monitoring target from the user to the debugging system having a processor A trace instruction execution function for receiving the received trace instruction; A trace point setting function configured to set a trace point by inserting an 'undefined-exception code' into the application program according to the execution of the trace instruction; A trace function execution function that executes a user-defined trace function according to generation of a trap at the trace point during execution of the application program setting the trace point; And a computer readable recording medium having recorded thereon a program for realizing a trace message output function for outputting a trace message obtained by executing the user trace function. A computer readable recording medium having recorded thereon a program for further realizing a trace point addition setting function for additionally setting a trace point in the application program according to execution of a trace instruction for adding a trace point is provided. Is a computer that records a program for further realizing a tracepoint deleting function for deleting a tracepoint set in the application program according to execution of a trace instruction for deleting a tracepoint received from the user. It provides a recording medium that can be read by.

Hereinafter, exemplary embodiments of the present invention will be described in detail with reference to the accompanying drawings.

1 is an explanatory diagram of a multi-task remote tracepoint debugging environment according to the present invention. The host computer 10, 11, 12 is a cross-compiler 16 based on an OS 11 or more of a Windows NT (NT) class. And an Esto ToolSet 10 having a source code editor 17, a tracepoint debugger 18, and a host debugging agent 19, on the target board side an information dedicated processor 14 Qplus real-time operating system kernel based on the target debugging agent process for processing the debug command and tracepoint command from the host and the application tasks under the control of the agent process, and the information-only target system and It consists of serial and Ethernet lines 15 that physically connect the host computer.

The present invention, like the hardware debugging technique that uses a trace point to monitor signals in the multi-task remote debugging development environment, by downloading a multi-task program to the target in the host computer, each of the monitoring trace points without damage to the original program It is about realizing the debugging technique to find the bugs occurred during real-time execution by collecting the result directly from the host while setting up and executing the tasks.

2 is an embodiment configuration diagram of a software function block for tracepoint debugging according to the present invention.

The host side is composed of a trace command input unit 20, a trace message output unit 21, and a trace point debugging engine 23 to set / release a trace point in a target multitask program. There is a host debugging agent 24 for connecting the 21 " and " 23 " and the target system with a remote procedure call (RPC) function.

The target side includes a target debugging instruction processor 27 for processing in response to a tracepoint-related command from the host, a tracepoint adder / deleter 28 for actually adding / deleting a tracepoint to a multi-task program, and an application program. (26) The trace triggering processing unit 29 is configured to perform a user trace function according to the generation of a trace point trap.

The developer analyzes the program to be tested non-stop, uses the editor to create a trace map file and a user-defined trace function, and then tests the test case and the test. Compile the program through the cross-compiler and download the object files to the target.

Here, the user-defined trace function refers to a C language function to be called at the time when the set trace point is executed while the application program 26 in which the trace point is set is executed. You can print local or global variables, memory and registers, stacks, message queues, semaphores, etc. Writing this function is the same as writing a regular C language function.

Then, the trace point is set in the test program of the target through the trace command input unit 20, the trace point debugging engine 23, and the host debugging agent 24.

In the target, a tracepoint add command is obtained through the target debugging command processor 27, and accordingly, a tracepoint is directly inserted into application tasks through the trace add / delete 28.

Tracepoints are set at the assembly-code level by replacing the 'undefined-exception code' with an assembly instruction in the test program. If you encounter an exception code, the Qplus kernel generates an exception trap.

By the trap signal, the triggering processor 29 reacts to perform a user-defined trace function, and performs an appropriate function based on the trace point information. The result of the function execution is sent to the trace message output unit 21 in real time through the serial line and stored in the hard disk 22 of the host computer for postmortem analysis.

2B is a flowchart illustrating a method for setting a trace point for non-stop debugging of a multi-task program according to the present invention.

Hereinafter, the trace point setting process 200 for non-stop debugging of a multi-task program will be divided into four steps.

The first step is to process the trace debugging command (see Fig. 3, Fig. 5 to Fig. 11). Input the user command to enable / disable the monitoring trace point in the host computer and to download and execute the test program. And performing the corresponding instructions (201).

The second step is to turn on / off the monitoring tracepoint (see Figures 12 and 13), which directly inserts or restores undefined-exception code to the application program on the target processor or to the original instruction. The target tracepoint setting / release step is performed (202).

The third step is the execution of the application task and the execution of the user trace function call (see FIG. 14), which is a triggering processing step that actually triggers the triggering function as a trap occurs at the trace point during the execution of the application program (203). .

The fourth step is outputting and storing the trace message (see FIG. 4). The trace message acquired through the trace function triggered (function call) at the trace point is obtained and output through the serial line (204).

After the four steps are performed, there is an application program error correction step, which is a step of correcting bugs found in the debugging process using the trace point (205).

3 is a flowchart illustrating a trace command input processing method according to the present invention.

Debugging instructions for loading / unloading and running test programs and test cases, tracepoint mapping / unmapping related to tracepoint processing, tracepoint on / off, and trace information instructions, and also test cases When creating a test-case, input a local variable information view command for a user-defined trace function, etc. (300), parse the command (301), and generate a command table according to the parsing result (command). table 302).

It is determined whether the search result is a trace instruction or a debugging instruction (303, 304) and executes an appropriate instruction function corresponding to the trace instruction or debugging instruction (305) (see FIGS. 5 to 11). ", That is, go to the command entry routine and wait for the next command.

If the input command is a quit command (306), the program is terminated (307).

4 is a flowchart illustrating a method of outputting a trace message according to the present invention, which starts with opening a serial line communication (401), waits for a serial event (402), and is a text receiving event. Check (403).

In the result of the check 403, if it is not a text reception event, it is determined whether the serial communication is closed (405). If the serial communication is closed, the program is terminated with the serial communication close (409) (410), and the serial communication closes. Otherwise, the process goes back to waiting for the serial event of "402".

In the check result 403, in the case of a text reception event, the communication error status is checked (404), and if there is no communication error, the text reception amount calculation (406), the actual text reception (407), etc. are performed. It outputs a text message in the window and saves the trace message on the hard disk (408), and if there is a communication error, it returns to the serial event waiting process of "402".

FIG. 5 is a flowchart illustrating a method of processing an info trace command according to an exemplary embodiment of the present invention, and illustrates a detailed processing flow of an info trace command found as a result of the trace command input processing of FIG. 3. .

Steps of reading and displaying the tracepoint information set from the tracepoint_chain in order (501-506) and the tracepoint information of the tracepoint chain (tracepoint_chain) when the mapping file name is given as an input of the view trace information command And saving to the mapping file (507-514).

Hereinafter, FIG. 5 will be described in detail.

First, it checks whether the tracepoint chain (tracepoint_chain) exists (501), and if the tracepoint does not exist, outputs a "No tracepoints" message indicating that the currently set tracepoint is not in the tracepoint chain (502), and the tracepoint If is present, information from the beginning of the tracepoint chain to the end of the tracepoint chain is output.The tracepoint chain is assigned to the trace variable to obtain the starting point of the tracepoint chain using a variable called trace. After that (503), it is checked whether the trace variable is a null value and whether it is the end of the tracepoint chain (504).

As a result of the check 504, if the trace variable is not null, trace point information regarding a corresponding trace number, a trace point address, a tracing function, and an function input value is obtained. Printing (505), converting the current trace variable to the next trace information by assigning the trace variable using the "next" field information of the current trace (506), and again checking if it is the end of the tracechain (504). Return to

If the check result 504, the trace variable value is null, go to the next step (507 to 515) to save the trace point information to a file.

The next step is to save the tracepoint information of the tracepointchain (tracepoint_chain) into the mapping file when the mapping file name is given as the input of the info trace command. First, the input value is null. If not, it is determined whether or not (507).

As a result of the determination 507, if the input value is NULL (args == NULL), the trace information viewing command is terminated.

As a result of the determination (507), if the input value is not null (args! = NULL), the argument is assigned to the filename variable (508), and then the file is used using the filename variable. Open (509) assigns the start point of the tracepoint chain to the trace variable (510), and then checks whether it is the end of the tracepoint chain (511). In this case, if the trace variable value is set to null, it is recognized as the end of the tracepoint chain.

As a result of checking "511", if the tracepoint value is not null, information about the source file name and the corresponding line number where the tracepoint is set and the tracepoint address and trace function are stored in the tracepoint mapping file ( 512, assigns the next trace of the current trace to the trace variable (513), and again determines whether the trace variable is null (511) and closes the file if the tracepoint is null. After 514, the view trace information command ends.

As a result of confirmation of " 511 ", when the trace point becomes null immediately, the file is immediately closed (514), and then the trace information viewing command is terminated.

6 is a flowchart illustrating a trace setting command processing method according to the present invention, and shows a detailed processing flow of the trace setting command found as a result of the trace command input processing of FIG. 3.

The trace configuration command is used to set the user trace function "user_func_1" to have parameter 100 on line 53 of the "gdb_test_b.c" test program, such as "trace gdb_test_b.c: 53 user_func_1 100". It is determined whether the input value of the command exists, that is, whether the value of the args variable is null and processed (601).

As a result of the determination 601, if there is no input value of the trace setting command (when args is null), the command execution is terminated.

As a result of the determination (601), if an input value of a trace setting command exists (args is not null), a file name, a line, a trace function, a function input value, etc. are obtained from the args variable ( 602), from them, for example, "gdb_test_b.c: 53", the symbol table and line (symtable_and_line) information of the source file are obtained (603).

After obtaining the actual trace point address of the target from the symbol table and line (symtable_and_line) information, "user_func_1 100" is parsed to obtain a target address and a function input value of the user trace function, respectively (604).

At this time, if the target address is not -1 (605), if the target address is -1, it indicates that the user-defined trace function is not loaded on the target (606), the trace setting command is terminated, and the target If the address is not -1, it checks whether the TracePointAdd function exists in the target (607).

As a result of the check at " 607 ", if the TracePointAdd function does not exist in the target, it indicates that the TracePointAdd function is not loaded in the target (608) and ends.

If the check result of "607" is present in the target, the tracepoint address (TracePointAdd) in the target table is transferred to the trPt_addr variable (609) of the trace function, that is, the symbol counter's program counter (symtable_and_line.pc). Set the target address to the trPt_callRtn variable (610) and the target argument value to the trPt_callArg variable (611), and call the target's TracePointAdd function (612) to set the tracepoint to the target, In step 613, a new tracepoint is registered in the tracepoint chain.

FIG. 7 is a flowchart illustrating an example of a method for processing a trace delete command according to the present invention, and illustrates a flow of a trace delete command found as a result of the trace command input processing of FIG. 3.

Deletes the trace point set in the application program of the target. When a user inputs a command, such as "trDel 3" in the command input of FIG. 3, the trace point corresponding to the third point is deleted from the trace point chain information.

As shown in FIG. 7, it is checked whether the value of the args variable is null (701) and terminates when the value of the args variable is null, and the value of the args variable is not null. In this case, the contents of the args are parsed to obtain the corresponding tracepoint number (702), the trace information corresponding to the tracepoint number from the tracepoint chain (tracepoint_chain) is obtained (703), and whether the trace information exists. (That is, the trace variable value is not null) (704).

If the result of "704" is not null, the trace program counter (trace.pc) value of the trace is set in the trPt_addr variable of the target from the trace information (705), and the target tracepoint is deleted from the host (TracePointDelete). Call the function to perform it (706).

As a result, if the tracepoint is deleted normally, the user is notified that the tracepoint corresponding to the trace unique number (trace.number) has been deleted (707), and the trace information is deleted from the tracepoint_chain ( free) (708).

If the result of "704 'is null, it ends.

FIG. 8 is a flowchart illustrating an example of a method for processing a tracemap command according to the present invention, and illustrates a flow of a trace mapping command found as a result of the trace command input processing of FIG. 3.

The trace mapping instruction reads the trace point information from the trace mapping file and sets the trace information in the target application code.

When inputting as "traceMap trace.map" in the command input process of FIG. 3, this reads tracepoint information from a "trace.map" file and sets a tracepoint on a target.

As shown in FIG. 8, by checking whether the value of the args variable is null as an input value of the traceMap command (801), if the args variable value is null, the operation ends. If the value of the args variable is not null, obtain the trace mapping file name from args (802), open the mapping file (803), get the value of the 'mapfile' point variable, and the 'mapfile' point variable is the end of the file. Check 804 the authorization (file_end_of_file).

As a result of the investigation of "804", if the trace mapping file is not the end, the following steps are repeated until the end of the file. Here, the trace mapping file is recorded on a storage medium such as a hard disk with information consisting of a trace source file name and line, a trace function, and its argument values.

First, the file name, line, trace function (trace_func) and argument (trace_arg) information are read from the trace mapping file (805), and the existing trace information is obtained from the file name and the line information. In operation 806, it is determined whether there is trace information (operation 807).

As a result of the determination 807, if the trace information exists on the tracepoint chain, the tracepoint of the target is added once again using trace_no, trace_func, and argument_trace information. TracePoint is reset through the TracePointAdd) function (809).

As a result of the determination 807, if the trace information does not exist on the tracepoint chain, new tracepoint information is added using the tracepoint adding function corresponding to FIG. 6 (808).

The above process is performed until the end of the file. If the result of the investigation of "804" is the end of the trace mapping file 811, the process is terminated by closing the file (810).

FIG. 9 is a flowchart illustrating an example of a method for processing a traceUnMap command according to the present invention, and illustrates a processing flow of the trace map unmap command found as a result of the trace command input processing of FIG. 3.

Trace information is extracted one by one from the tracepoint_chain, and the tracepoints set in the target are deleted (903), and individual tracepoints are deleted according to the tracepointDelete instruction flow chart of FIG. 7. .

First, it extracts the first trace information from the tracepoint_chain (901) and checks whether the trace variable value is not null (902). Using the tracepoint number, tracepoint address, etc. of the trace variable, the tracepoint delete function of the target is called to delete the tracepoint from the target (903), and the next trace variable from the current trace variable is called. In operation 904, the process returns to step 902 for determining whether the trace information is present.

Deleting all trace points set in the target indicates that all trace points have been deleted (905) and ends the unmap trace command.

FIG. 10 is a flowchart illustrating a method for processing a local variable view command according to the present invention, and shows a processing flow of the local variable view command found as a result of the trace command input process of FIG. 3.

This function allows developers to access the local variable value of a test program's specific function from the user trace function assigned to the tracepoint by outputting the relative offset address of the local variable values from the specific function of the target application program. This function allows you to do this. According to the command input of FIG. 3, when inputted as "local MAX", the local variable view command processing function displays the name, type, and offset address value of local variables in the MAX function.

As shown in FIG. 10, depending on whether or not args exist after the local variable view instruction (1001), a function name (func_name) is obtained from arg if present (1002), and the function name (func_name) at the host. A block vector of a symbol corresponding to the block vector is obtained (1003), and the number of symbols of the block vector is obtained (1004).

According to the number of symbols in the block vector, the symbol type and name are sequentially printed, and the offset value from register 11 of the corresponding function is output. First, set the symbol count variable to 0 (1005), determine whether the count variable is smaller than the number of symbols (1006), if small, print the type and name of the local symbol (1007), Printing the offset address value from register 11, the base address of the corresponding local symbol (1008), and then increasing the value of the count variable by one and checking whether it is smaller than the number of symbols (1006). Go to. If the count value is larger than the number of symbols, the processing of the local variable view command ends.

FIG. 11 is a flowchart illustrating an example of a method for processing a global variable view command according to the present invention, and illustrates a processing flow of the global variable view command found as a result of the trace command input process of FIG. 3.

The global variable view (global) command displays the global variables to be used in the trace function connected to the trace point. As shown in FIG. 11, the global variable information is simply output as many as the number of global variables of the test program.

First, in order to display the registered global variable variable information, the index variable is initialized to "0" (1101), and it is checked whether the index variable value is smaller than the number of currently registered global variables ( 1102).

As a result of the check 1102, if the value of the index variable is smaller than the number of registered global variables, information on the global variable name and address of 'globalvariables' corresponding to the current index value is printed. In step 1103, the current index value is increased by one (1104), and then the process returns to step 1102 in which it is determined whether the number is less than the number of global variables.

As a result of the check 1102, if the index variable value is larger than the number of the currently registered global variable, the user is notified with a message that the global variable is displayed (1105), and the command for viewing the global variable ends.

12 is a flowchart illustrating an example of a method for processing a trace point addition in a target according to the present invention, which is a function called to actually add a trace point in a target during host command processing of FIGS. 6 and 8. In order to insert exception code at specific location of tasks in multi-task program environment, create tracepoint struct using trPt_TaskId and trPt_addr variables and register it to breakpoint chain. do. At this time, 'tracepoint.action.actionType' value is set to 'QDB_ACTION_TRACE' to prevent confusion with existing breakpoint information.

Specifically, according to the processing flow of FIG. 12, first, a tracepoint structure having a QDB_ACTION_TRACE type is generated using trPt_addr, trPt_TaskId, trPt_CallR number, and trPt_CallArg variable information (1201 to 1207). tracePoint.evtType) is the "QDB_EVT_BP" value (1201), the tracepoint's context type (tracePoint.context.contextType) is the "QDB_CTX_TASK" (1202), and the tracepoint's context ID (tracePoint.context.contextId) is the trPt_TaskId value. (1203), the action type (tracePoint.action.actionType) of the tracepoint is set to "QDB_ACTION_TRACE" (1204), the argument is set to 0 (1205), and the calling routine and the passing argument value at the tracepoint are respectively Set to trPt_callRtn and trPt_callArg (1206, 1207).

This tracepoint structure is registered in the breakpoint chain (1209-1212), and it is checked once (1208) that the memory at the address trPt_addr location of the tracepoint is valid.

As a result of the check 1208, if the address of the trace point trPt_addr memory is valid, the tracepoint structure is converted into a breakpoint structure (1209). Copy the instruction to this breakpoint structure (1210), add the modified breakpoint structure to the breakpoint list (named bpList) (1211), and add an exception code to the address of the tracepoint. code is inserted instead (1212).

If this code is executed during execution, the Qplus kernel generates an exception trap and automatically executes the triggering processing function of FIG.

As a result of the check 1208, if the address (trPt_addr) memory of the trace point is invalid, the memory is not written (1213), and the trace point adding process at the target is terminated.

FIG. 13 is a flowchart illustrating an example of a method for processing tracepoint deletion (release) in a target according to the present invention, which is a function called to actually delete a tracepoint in a target during processing of a host command of FIG. 7.

It is checked whether or not to delete all trace points of the target (1301).

As a result of the check 1301, if all tracepoints are deleted, the tracepoint is deleted from the breakpoint chain (1304), and then the instruction is restored to the original code (1305), and the information on the deleted tracepoint is restored. The process of deleting tracepoints by adding to the tracepoint free list (bpFreeList) (1306) is repeated 1303 from the beginning of the breakpoint chain (1302) (ie, until all tracepoints are deleted).

As a result of the check 1301, when deleting a specific trace point (1307) from the beginning of the breakpoint chain (1307) to the end of the breakpoint, the tracepoint (ie, bp_addr such as trPt_addr) to be deleted has After finding the breakpoint structure (1309), deleting the tracepoint from the breakpoint chain (1310), restoring the instruction to the original code according to the instruction field information of the particular tracepoint that was deleted (1311), and deleting the deleted tracepoint. The function execution is completed by adding the information of the to the tracepoint free list (1312).

14 is a flow chart of an embodiment of a triggering method in a target according to the present invention, in which the triggering process in the target inserts an undefined-exception code into the tracepoint of the application as in the breakpoint process. When this exception code is executed during execution, an exception is generated and the qdbTrap exception handler of FIG. 14 is executed.

Once an exception trap occurs due to an undefined-exception code (1401), the program counter (pc) value of the currently performed task is stored in a trap address (trap_addr) variable (1402). In operation 1403, it is determined whether a trap generated at the task level (that is, generated in an application program) is detected.

As a result of the determination 1403, if it is not a task level trap, it ends, and if it is a task level trap, exception trap processing is performed using a trap address (trap_addr) variable value (1404 to 1409).

However, an undefined exception code is used at the breakpoint and the tracepoint at the same time, so when an exception occurs (1401), it is caused by the tracepoint or by the breakpoint. The recognition is not clear. For this, bpInfo information corresponding to the current trap address is found (1404), and it is determined by determining whether the 'bpInfo.bp_action' information is 'QDB_ACTION_TRACE' (1405).

As a result of the determination (1405), if the bpInfo.bp_action information is an exception due to the trace point, QDB_ACTION_TRACE calls a user-defined trace function to collect tracing information (1406), and restores the instruction to the original code (1406). 1407) Complete this function.

As a result of the determination (1405), if the bpInfo.bp_action information is not a QDB_ACTION_TRACE but a trap due to a breakpoint, the breakpoint deletion and instruction are restored (1408), and the task breakpoint trap processing routine is called (1409).

As described above, the method of the present invention may be implemented as a program and stored in a recording medium (CD-ROM, RAM, ROM, floppy disk, hard disk, magneto-optical disk, etc.) in a computer-readable form.

The present invention described above is capable of various substitutions, modifications, and changes without departing from the spirit of the present invention for those skilled in the art to which the present invention pertains, and the above-described embodiments and accompanying It is not limited by the drawings.

The present invention as described above, a technique used when debugging without interruption of the embedded program, it is possible to analyze the system behavior by setting a trace point to monitor the system behavior and executing the necessary debugging code. This allows you to visualize the execution of the application, to obtain status online or to analyze the results collected from the tracepoint offline, and to assign new values to the variables of the running program without stopping any tampering or the original execution flow. It has the effect of providing a means to observe the logical execution flow of an application program.

In addition, the present invention has the effect of providing a condition that can be replayed on the host ultimately based on the data collected from the trace points.

Claims (12)

In the trace point setting method applied to a debugging system for debugging a multi-task program, A trace command execution step of receiving a trace command for executing an application program that is a trace point setting and a monitoring target from a user, and executing the received trace command; A tracepoint setting step of setting a tracepoint by inserting an 'undefined-exception code' into the application program according to the execution of the trace instruction; A trace function execution step of executing a user-defined trace function according to generation of a trap at the trace point during the execution of the application program setting the trace point; And A trace message output step of outputting a trace message obtained by executing the user trace function Tracepoint setting method for non-stop debugging of a multitasking program including a. The method of claim 1, A trace point addition setting step of additionally setting a trace point in the application program according to execution of a trace command for adding a trace point received from the user. Tracepoint setting method for non-stop debugging of a multi-tasking program further comprising. The method of claim 2, The trace point addition process of the trace point addition setting step, In order to insert an 'exception code' into a specific location of tasks in the application program, a tracepoint structure is generated using a tracepoint context identifier (ID) (trPt_TaskId) and a tracepoint address (trPt_addr), and the generation is performed. A method for setting a tracepoint for non-stop debugging of a multitasking program, comprising registering and adding a tracepoint structure to a breakpoint chain. The method of claim 1, A trace point deleting step of deleting a trace point set in the application program according to execution of a trace command for deleting a trace point received from the user Tracepoint setting method for non-stop debugging of a multi-tasking program further comprising. The method of claim 4, wherein The tracepoint deletion process of the tracepoint deletion step, To delete all tracepoints, delete the tracepoint from the breakpoint chain, restore the instruction to its original code, and add the deleted tracepoint information to the bpFreeList: breakpoint free list. Performing a process from beginning to end of the breakpoint chain; In the case of deleting a specific trace point, search from the beginning of the breakpoint chain to the end of the breakpoint, find a breakpoint having a specific tracepoint to delete, and then delete the specific tracepoint from the breakpoint, A method for setting a tracepoint for non-stop debugging of a multi-task program, comprising: restoring an instruction to original code according to the instruction field information of the deleted specific tracepoint and adding the deleted tracepoint information to a tracepoint free list. . The method according to any one of claims 1 to 5, The trace instruction execution step, A trace command input step of receiving a trace command from the user for setting a trace point and executing an application program to be a test target; And Parsing the received trace command and searching the parsed command from a command table to execute a corresponding command function according to the type of the retrieved command. Tracepoint setting method for non-stop debugging of a multitasking program including a. The method of claim 6, The command function execution step, Parsing the received trace command and searching the parsed command from a command table to determine the type of the retrieved command; Displaying and storing the trace point information status if the command is an info trace command; Setting a trace point to a specific instruction of the application program to be monitored if the instruction is a trace instruction; If it is determined that the instruction is a traceMap instruction, reading tracepoint information from a tracepoint mapping file and setting the read tracepoint information in an application code in a batch; If the command is a local variable view command, outputting offset address values of local variable values from a specific function of an application program loaded on a target; And If the command is a global variable view command, displaying the contents of a global variable of the application program; Tracepoint setting method for non-stop debugging of a multitasking program including a. The method according to any one of claims 1 to 5, The trace function execution step, Waiting for an exception trap occurring at a trace point of the application program; Obtaining a trap address at a trap time point and obtaining trap information using the trap address; Checking the cause of the generated exception trap when the exception trap occurs; If the check resulted in the exception trap being caused by a tracepoint, calling the user trace function to recover tracing information and restoring the instruction to the original code; And If the exception trap is caused by the breakpoint, deleting the breakpoint, restoring the instruction to the original code, and then performing a task breakpoint trap process Tracepoint setting method for non-stop debugging of a multitasking program including a. The method according to any one of claims 1 to 5, The trace message output step, Opening serial communication between a host computer and a target to receive a serial event from the target, and determining a type of the received serial event; If the received serial event is a text reception event, receiving the trace message and storing or outputting the received trace message to the user; And As a result of the determination, if the received serial event is not a text reception event, it is determined whether the received serial event is a serial communication close. Returning to the beginning of the trace message output step to receive a Tracepoint setting method for non-stop debugging of a multitasking program including a. In order to set up tracepoints for non-stop debugging of multitasking programs, A trace command execution function for receiving a trace command for executing an application program to be set as a trace point and a monitoring target from a user, and executing the received trace command; A trace point setting function configured to set a trace point by inserting an 'undefined-exception code' into the application program according to the execution of the trace instruction; A trace function execution function that executes a user-defined trace function according to generation of a trap at the trace point during execution of the application program setting the trace point; And A trace message output function for outputting a trace message obtained by executing the user trace function. A computer-readable recording medium having recorded thereon a program for realizing this. The method of claim 10, A trace point addition setting function for additionally setting a trace point in the application program according to execution of a trace command for adding a trace point received from the user. A computer-readable recording medium that records a program for further realization. The method of claim 10 or 11, A trace point deletion function for deleting a trace point set in the application program according to execution of a trace command for deleting a trace point received from the user. A computer-readable recording medium that records a program for further realization.