KR100461521B1 - Program Debugging Method using Assert Function in Switching System - Google Patents

Abstract

The present invention provides a useful tool when a user programmer writes a program and then wants to debug the function abnormality of the corresponding program so that the user programmer can easily find and correct the error, and the user-written program can be stably performed. This article describes how to debug a program using the Assert function in an exchange.

The present invention enables a user to debug his or her own program by a program that provides an assert function in the exchange, otherwise, outputs only the desired message among various types of messages, grasps the value of the parameter, By grasping and storing the register values, you can check the contents of the registers and check the name of each function at once, and stabilize the program by providing a debugging tool that allows the user to correct errors in the program. In addition, you can easily find the information by outputting only the message you want, and distinguish the parameter and data value, and find the function name in the symbol table of the file stored in the hard disk using the address value of the function. User can easily check the function name by There.

Description

Program Debugging Method Using Assert Function in Switching System

The present invention relates to a method for debugging a program using an assert function in an exchange. In particular, when a user programmer writes a program and wants to debug a malfunction of the corresponding program, a useful tool is provided to easily find an error. The present invention relates to a program debugging method using an assert function in an exchange so that a user-written program can be stably executed.

In general, a user who is a programmer writes an exchange program and then verifies and verifies the design of the program. The design verification and verification is an activity to ensure high reliability of the program system at the design stage. In other words, early detection of design mismatches and design errors for a more reliable program can reduce development costs.

In order to verify and verify the design of the program as described above, the program is debugged by using the assert function in the exchange. In the conventional exchange, the program assert function is not implemented, and the user uses the assert function in another exchange. The program to be debugged is implemented by, for example, a program as shown in Fig. 1A. Here, the program is an example program written in C and assembly language, 'pd_ASRT_A (asrtid, msg)' is a library function, and 'local_sec (33, rcvdata)' is a primitive function. FIG. 1B is a diagram showing contents stored in a user stack when a program as shown in FIG. 1A is executed.

The program is executed to output the information desired by the user to the MMC terminal and debug the method as shown in FIG. 2.

The user programmer calls the library function 'pd_ASRT_A (asrtid, msg)' by the corresponding program to a function suspected of causing an error in his program (step S201). Here, the beginning of the library function contains each register value but does not know the register value. Accordingly, the library searches for 'local_sec (33, rcvdata)', which is a primitive function, and then requests information using the corresponding primitive function (step S202). Accordingly, CROS (Concurrent Real-Time OS), which is an operating system (OS) for real-time processing, calls 'user1 (user1_i1, user1_i2)' and 'user2 (user2_i1, user1_i2)' sequentially through corresponding primitive functions, and FIG. 1B. After the information stored in the user stack as shown in FIG. 5 is acquired (step S203), the information is transferred to the library (step S204). Here, when the program is compiled, the part calling the function 'user1' within the function 'user2 (user2_i1, user2_i2)' and the part calling the function 'user2' within the function 'user3 (user3_i1, user3_i2)' The following contains the part of the machine code that knows the number of parameters, but does not grasp this. The library outputs the corresponding information to the MMC terminal, whereby the user debugs the program (step S205).

Here, 'Rts (of user2)', 'Rts (of user3)', 'user1_v1', 'user1_v2', 'user1_i1', 'user1_i2', and 'user2_v1' stored in the stack when the information is output to the corresponding MMC terminal. Output all 10 values at the same time, including 'user2_v2'. In addition, 'Rts (of user2)' and 'Rts (of user3)' are output as hexadecimal memory address values, and the function name of the corresponding user function must be identified as the hexadecimal memory address. .

As such, the conventional exchanger does not provide a debugging tool because a program assert function is not implemented, and thus a programmer requires a lot of time when debugging a program.

In addition, another conventional exchange simply outputs all the information stored in the stack to the MMC terminal by using the assert function, and thus, it is not only possible to distinguish which parameter or data value among the outputted information. It is very difficult for programmers to find only the messages they want from the various types of messages that are output on the MMC terminal, and it is impossible to check the information of the registers because they do not know the value of each register, which is an important value at the moment the library function is executed. There is a problem.

In addition, in the conventional exchange, the values of 'Rts (of user2)' and 'Rts (of user3)' are output as hexadecimal memory address values, so that the memory addresses of the hexadecimal numbers later have ' It is inconvenient to check the function name 'user2' and 'user3' respectively.

SUMMARY OF THE INVENTION The present invention has been made to solve the problems described above, and an object thereof is to provide a debugging method using an assert function that enables a user to debug his or her own program by a program that provides an assert function in an exchange. .

In addition, another object of the present invention can easily find the corresponding information by outputting only the desired message from the various types of messages in the exchange, it is possible to distinguish between the parameter and the data value by grasping the value of the parameter, It is to provide the debugging method using the assert function that checks the contents of the register because the register value is identified and stored, and the name of each function can be checked at once.

FIG. 1A illustrates a program to which an assert function is attached in an exchange according to the prior art, and FIG. 1B illustrates contents stored in a user stack when performing a corresponding program.

2 is a flowchart illustrating a program debugging procedure in an exchange according to the prior art;

3 is a flowchart showing a procedure at the time of debugging according to the present invention;

4 is a flowchart illustrating a procedure of processing an instruction by a processor during debugging in accordance with the present invention.

Features of the present invention for achieving the above object, the process of receiving a name and instructions of the processor under debugging via the dummy terminal when the user requests the error information of the program; Extracting information stored in a memory by the processor according to the received instruction; Retrieving a function table of an address of the extracted information by searching a symbol table of a hard disk; And sorting the information stored in the memory and the function name obtained from the hard disk together and outputting the same to the dummy terminal.

Hereinafter, a program debugging method using an assert function in an exchange according to a preferred embodiment of the present invention will be described with reference to the accompanying drawings.

According to the present invention, a modified library function 'pd_ASRT_A ()', a modified primitive function 'local_sec ()', and an application program are added to a processor of an exchange to process an instruction of an operator coming from a dummy terminal. It consists of a function (eg 'ASERT_FUN ()'). The method of the present invention then implements a function, for example 'ASERT_FUN ()', that first processes the operator's instructions, as shown in FIG. Then, the user requests the error information of the program through the dummy terminal. At this time, the user inputs a corresponding command together with the name of the processor being debugged using 'ASERT_FUN ()' (step S301). The processor extracts the error information stored in the memory (step S302). Then, the processor searches the symbol table of the file stored in the hard disk of the exchanger to determine which function the address for the user information is included in, and finds the function name of the address for the information ( Step S303). Then, the information extracted from the memory and the function name retrieved from the hard disk are sorted together (step S304) and output to the dummy terminal for debugging by the user (step S305). Meanwhile, the process of storing the information in the memory (step S305). S302 proceeds in the order shown in FIG. First, when a program is driven, a library function is called (step S401). The library function contains each register value at the beginning, and reads the register value and stores it in the corresponding variable. The library then stores the register value for the corresponding information (step S402), and then requests the desired information from CROS, which is an operating system (step S403). CROS then extracts the corresponding information stored on the stack using the primitive function (step S404). Here, when the program is compiled, the next part of calling the previous 'user' function included in the 'user' function in the primitive function includes a part of machine code that can determine the number of parameters of the previous 'user' function. . Here, the next part of the function call is made of one of a predetermined number of machine language codes, and the machine code is four kinds of '588f', '508f', '4fef' and 'dffc'. The number of parameters of the above machine code is '588f' is 2, '508f' is 4, '4fef' is half the value stored in 2 (Byte) arranged next, and 'dffc' is the next 4 (Byte). Half of the values stored in are the number of parameters. For example, if 2 (Byte) after '4fef' in machine code indicates '10', the number of parameters is 5, and 4 (Byte) after 'dffc' indicates '14'. The number is seven.

Thereafter, CROS transfers the information extracted from the stack back to the library, and the library transfers the extracted information to the processor using IPC (Internet Protocol Control) communication (step S405), and the processor transfers the extracted information. Store in memory. In this case, a function (for example, 'ASERT_FUN ()') for processing a user's instruction and storing the information in the memory is defined in the processor, and the time for which the information is stored in the memory is also stored (step S406). ).

Although the preferred embodiments of the present invention have been described in detail above, it will be understood by those skilled in the art that the present invention may be modified or modified in various ways. Therefore, changes of the embodiments of the present invention will not be able to escape the technical scope of the present invention.

As described above, the present invention has an advantage of stabilizing a program by providing a debugging tool that allows a user to correct an error in a program even in an exchange.

In addition, the exchanger can output only the message that the user wants when debugging, and can distinguish the parameter and data value, and the function name is identified in the symbol table of the file stored in the hard disk using the address value of the function. The advantage is that the function name can be checked by the user.

Claims (2)

Receiving a name and an instruction of a processor under debugging through a dummy terminal when a user requests error information of a program; Extracting information stored in a memory by the processor according to the received instruction; Retrieving a function table of an address of the extracted information by searching a symbol table of a hard disk; And arranging the information stored in the memory and the function name determined from the hard disk together and outputting them to the dummy terminal. The method of claim 1, The extracting of the information stored in the memory may include: calling a library function of the program when the program is driven; Calling the library function, storing a register value included in the library function in a variable corresponding to the library, and then requesting information desired by a user from a concurrent real-time OS (CROS) using a primitive function; Receiving an information request from the CROS, acquiring information stored in a stack, and transferring the information stored in a stack to the processor via the library; Receiving the information from the processor and storing the information in the memory.