JPH09146776A - Object generation method and debugging method - Google Patents

Abstract

(57) [Abstract] [Problem] To improve the efficiency of software debugging. By adding a process for embedding an object name (object name) to an initialization function, only a function called from a specific object can be broken in debugging the object (S11). (S14), it is possible to set a breakpoint by combining the conditions of the object and the function in this way, thereby improving the efficiency of software debugging.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a software development support technique and a technique for improving the efficiency of software debugging.

[0002]

2. Description of the Related Art An object module (also referred to simply as "object") created by a C compiler or assembler or a load module created by a linkage editor can be debugged by a debug system. Such an object module or load module is called a debug target program. A program or program to be debugged can be actually executed, and an error in the program can be detected by following the execution locus. Debuggers and simulators are known as such tools.

The debugger executes a debug target program and writes a result of execution into a trace buffer every execution of one instruction by a designation, and a break condition is satisfied when a break condition is satisfied during execution of the debug target program. It has a break function to display the message and interrupt the program execution. As break conditions, breaks due to the satisfaction of break command conditions,
There are breaks due to error detection during execution of the debug target program and breaks due to interrupt key input.

An example of a document describing a debugger is "Microcomputer Handbook (Page 569-)" issued by Ohm Co., Ltd. on December 25, 1985.

[0005]

In debugging a high-level language program, it is sometimes desired to set a breakpoint of the program inside the function and suspend the program execution when the processing reaches the position of the breakpoint.
However, even if a breakpoint is set inside the member function and the program execution is suspended there, the object that called the member function at the breakpoint cannot be examined. In the debugger, the debug information of an object consists of information that indicates the structure of the type of the object and static information that indicates the offset position.
This is because it is not possible to specify an object that changes dynamically during program execution. For example, in FIG.
Considering the case where there is a function call from the source program 1 to the source program 2 as shown in FIG. 3, the information that the debugger can refer to when the program execution process is inside the function is shown in FIG. As described above, it is the member position information of the object based on the offset position of the object and the type information of the object, and it is not possible to specify either of the object names a1 and a2. That is, when the process execution is moved to the inside of the function by the function call, it is impossible to determine whether the function call is due to a1 or a2. Therefore, the break point is necessarily "a1.f ()",
Alternatively, even if setting to "a2.f ()" is required, and it is desired to break only the function called from a specific object like "a1" or "a2", that cannot be done.

An object of the present invention is to improve the efficiency of software debugging.

Another object of the present invention is to provide a technique for enabling the setting of breakpoints that combine the conditions of objects and functions.

The above and other objects and novel features of the present invention will become apparent from the description of the present specification and the accompanying drawings.

[0009]

The following is a brief description of an outline of a typical invention among the inventions disclosed in the present application.

That is, when an object is generated based on a source program, by embedding the information of the object name that enables the identification of the object inside the object, the inside of the function grasps the object that called it. Is possible.

As a concrete mode, when an object is generated, a user-defined size is obtained (S1),
Based on the pointer size and the character size of the object name, the size required for embedding the information of the object name is obtained (S2), and based on the obtained size, the information of the object name that enables the object to be identified inside the object. To be embedded.

In debugging the object generated as described above, the object name relating to the function call is specified based on the information of the object name embedded inside the object.

Further, in the break processing in the above debug, a breakpoint is set at an arbitrary program line inside the function called by the specified object, and the address indicated by the program counter becomes
It is determined whether or not the address of the above function matches (S1
1) Based on this determination result, the address of the object name is acquired from the object (S12), the object name is acquired from the address (S13), and the acquired object name is the object related to the breakpoint setting. Is determined (S14),
The program execution is suspended based on this determination result.

[0014]

DESCRIPTION OF THE PREFERRED EMBODIMENTS FIG. 2 shows a software development support system to which a method according to an embodiment of the present invention is applied.

This system includes an arithmetic processing unit 21 for performing predetermined arithmetic processing by executing various programs related to software development support, a display unit 22 for displaying information, and an input / output unit 23 for various information. The processor 21 includes an assembler 211 for translating a source program written in assembler language to generate an object module, a compiler 212 for translating a source program written in a high-level language to generate an object module, A librarian 214 for converting the object module into a library, a linkage editor 215 for linking a plurality of object modules, a simulator / debugger 21 having a function as a simulator and a function as a debugger.
6, and the target CPU information analysis means 213 for creating various information files regarding the microcomputer (target CPU) in which the software to be developed is actually used are functionally realized by executing a predetermined program.

FIG. 6 shows a flow of creating a debug target program by the software development support system.

The assembler source program written in the assembler language is translated by the assembler 211 to generate the object module 13. A source program written in a high level language is translated by a compiler to generate an object module 13. The object module 13 generated by the assembler 211 or the compiler 212 is converted into a library by the librarian 214, and the library file 14 is created thereby. Further, the plurality of object modules are combined by the linkage editor 215, thereby generating the load module 16. The load module 16 is debugged by the simulator / debugger 216.

Next, the object generation will be described.

FIG. 4A shows an example of a C ⁺⁺ source program.

In FIG. 4 (a), "struct
"A" is a user-defined type. “Struct” is a declaration of a structure and its type name is “A”. Then, "int a" that follows indicates that an area for the int type variable a is secured in the memory, and "lot"
"ng b" indicates that the area of the long type variable b is secured in the memory. area of int type variable a,
The areas of the long type variable b and the long type variable b are each 4 bytes, although not particularly limited thereto. Furthermore, the variable a,
An initialization function for b is described, where "a =
2 ”and“ b = 10 ”. Then, “A aa;” is described after the initialization function. This “A aa;” means the setting of the object name, and the compilation for it is done by the compiler 212.
Is processed as follows.

FIG. 4 (b) shows the flow of the compiling process for "A aa;".

In this compile process, the object name is embedded in the object by adding a process for embedding the object name (object name) to the initialization function.

First, the size of the user-defined type (A) is obtained (step S1). In this example, "int
Since “a” and “long b” are each 4 bytes, the size of the user-defined type (A) is 4 + 4 = 8 (bytes).

Next, the size required to embed the object name (aa) is obtained (step S2). In this embodiment, since the size of the pointer for holding the address of the object name setting area is 4 bytes and the character size of the object name (aa) is 2 bytes as the information of the object name, the object name (aa) 4 + 2 = 6 bytes are required to pad the.

Then, according to the initialization function, FIG.
As shown in, the object is set in the memory (step S3). At the beginning of the object, a pointer storage area 41 for pointing to the address of the object name storage area 42 is formed, and subsequently data (a = 2, b = 10) is set. Then, one object has data (b = 1
Up to 0), and after that, the storage area 42 of the character (aa) indicating the name of the object is set. In this embodiment, since the data a = 2 and b = 10 each have 4 bytes, the address of the object name storage area 42 is 8 bytes ahead of the pointer storage area 41. That is, in this embodiment, as shown in FIG. 5B, “address with object name (aa)” and “object name = aa” for the initialization function shown in FIG. Is added, and the object name is embedded. By embedding the object name in such a manner, the name of the object can be grasped from the address having the object name in the debug processing described later.

The debugging of the object generated as described above will be described.

FIG. 1 shows a flow of processing regarding a break by the debugger 216.

The debugger 216 executes the debug target program and writes the execution result to the trace buffer every execution of one instruction according to the specification, and the break condition when the break condition is satisfied during the execution of the debug target program. It has a break function that displays a success message and suspends program execution. Break conditions include breaks when the break command is satisfied, breaks when an error is detected during execution of the debug target program, and breaks when an interrupt key is entered. .
In this embodiment, as a break command, in addition to simply setting a breakpoint in the function f, as in the case of setting a breakpoint immediately before the processing of the function f is started for specific data, There is a command that allows you to set breakpoints that combine the conditions of objects and functions. For example, "bre
By specifying "ak a->f", a breakpoint can be set for the data a immediately before the processing of the function f is started. If a breakpoint is set by such a break command, the debugger 2
At 16, processing is performed as shown in FIG.

Every time the output address of the program counter is updated, it is determined whether or not the value of the program counter (PC) and the value of the function f () match (step S11). In this determination, when the value of the program counter (PC) and the value of the function f () do not match (no), the break condition is not satisfied, and the value is dealt with based on the value of the program counter (PC) at that time. The command is executed. In the determination in step S11, the value of the program counter (PC) and the function f ()
If it is determined that the value of the object has coincided with the value of (yes), the address of the object name is acquired by the pointer before executing the command corresponding to the value of the program counter (PC) at that time (step S12). The object name is acquired based on the address (step S1)
3). Then, it is determined whether or not the object name designated by the user matches the object name (aa) (step S14). In this determination, if it is determined that they match (yes), the necessary information is displayed on the display device 22 and the execution of the debug target program is interrupted due to the establishment of the break condition at the breakpoint. If it is determined in step S14 that the object name specified by the user and the object name (a) do not match (no), the command corresponding to the value of the program counter is executed because the break condition is not satisfied. Then, the process proceeds to the determination in step 11 above. In this way, it is possible to set a breakpoint that combines the object and the condition of the function, so by setting the break condition at the desired position inside the function and making it possible to grasp the operating state in that case. It is possible to improve the debugging efficiency.

According to the above embodiment, the following operational effects can be obtained.

(1) In compilation, a process for embedding an object name (object name) in the initialization function is added, so that as shown in FIG. Even when there is a function call to 2, the object name can be referenced in addition to the member information of the object from the offset position of the object and the type information of the object when the program execution process is inside the function.
When the process execution is moved to the inside of the function by the function call,
It is possible to determine whether the function call is due to a1 or b1, and thus it is possible to improve the software debugging efficiency.

(2) Further, as described above, by adding the processing for embedding the name of the object (object name) to the initialization function, in debugging the object, it is called from a specific object. It is possible to break only the function (S11-S1
4) In this way, it becomes possible to set breakpoints that combine the conditions of objects and functions, so that the efficiency of software debugging can be improved.

The invention made by the present inventor has been specifically described based on the embodiments, but the present invention is not limited thereto, and needless to say, various modifications can be made without departing from the scope of the invention. Yes.

For example, in the above embodiment, the case where the C ⁺⁺ source program is used has been described, but the present invention is not limited to the C ⁺⁺ language, and various object-oriented language programs can be used.

In the above embodiment, the pointer is used to secure the storage area 42 of the character (aa) of the object name in the memory. However, instead of the pointer, it is for the debug information set for each object. By embedding an ID number or the like, the object can be immediately identified by the embedded ID number.
It is not necessary to secure the storage area 42 of a) in the memory.

In the above description, the invention made by the present inventor was mainly applied to debugging the compiler which is the background field of application and the object generated by the compiler, but the present invention is not limited thereto. It can be applied to debug the assembler and the objects it creates, not the ones.

The present invention can be applied on condition that at least an object is generated.

[0038]

The effects obtained by typical ones of the inventions disclosed in the present application will be briefly described as follows.

That is, in the compilation, the processing for embedding the object name (object name) in the initialization function is added, so that when the program execution processing is inside the function, the offset position of the object and the object Since it is possible to refer to the object name in addition to the member information of the object from the type information, it is possible to determine the callee of the function when the processing execution is moved to the inside of the function by the call of the function. Can be improved.

Further, by adding the processing for embedding the object name (object name) to the initialization function as described above, it is possible to break only the function called from a specific object, It is possible to set breakpoints that combine the conditions of functions. In this way, it is possible to determine the callee of the function and set a breakpoint that combines the conditions of the object and the function, thereby improving the debugging efficiency.

[Brief description of the drawings]

FIG. 1 is a flowchart of a main part of a compilation process to which a method according to an embodiment of the present invention is applied.

FIG. 2 is a functional block diagram of a software development support system for performing the compilation process.

FIG. 3 is a structural explanatory diagram of types of objects to be compared with objects in the present embodiment.

FIG. 4 is a flowchart of a compile process for a source program and its main part in the present embodiment.

FIG. 5 is an explanatory diagram of types of objects in this embodiment.

FIG. 6 is a flowchart for creating a debug target program by the software development support system.

[Explanation of symbols]

 11 assembler source program 12 source program written in high-level language 13 object module 14 library file 15 CPU information file 16 load module 21 arithmetic processing unit 22 display device 23 input / output device 41 pointer storage area 42 object name character storage area

Claims (4)

[Claims] 1. An object generation method for generating an object to be debugged based on a source program, including a step of embedding information on an object name that enables identification of the object inside the object. Object generation method. 2. An object generation method for generating an object to be debugged based on a source program, the first step of obtaining a user-defined size, and the object name based on the pointer size and the character size of the object name. The second step of obtaining the size required for embedding the information, and the object can be identified inside the object based on the size obtained in the first and second steps when the object is set by the initialization function. And a third step of embedding the information of the object name to be executed. 3. A debugging method for debugging an object generated by the object generating method according to claim 1 or 2, wherein an object name relating to a function call is specified based on information of the object name embedded inside the object. A debugging method comprising the steps of: 4. A fourth step of setting a breakpoint at an arbitrary program line inside a function called by a specified object, and whether the address indicated by the program counter matches the address of the function. The fifth step of determining the object name, the sixth step of obtaining the address of the object name from the object based on the determination result, the seventh step of obtaining the object name of the object name address, and the obtained object name And an eighth step of determining whether or not matches the object related to the breakpoint setting, and a ninth step of interrupting the program execution based on the determination result.
The debugging method according to claim 3, further comprising: