JPH10161904A - Debugging device and debugging method for multiple languages - Google Patents

Abstract

(57) [Summary] [PROBLEMS] To provide a debugging device which realizes efficient debugging by managing switching of programming languages. A debugger sets a shadow point different from a break point set at an arbitrary position by a user in all entries included in an execution load module arranged on a memory. And when control shifts due to this hidden breakpoint,
The target language type is compared with the current language type, and if the language type is different, it is determined that language switching has occurred, and watchpoint information corresponding to the target language type is read from the watchpoint table 141, and this readout is performed. The watch point register 2 is reset according to the watch point information.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a debugging apparatus and a debugging method suitable for debugging programs constructed in a plurality of types of programming languages.

[0002]

2. Description of the Related Art Conventionally, there are two or more types of programming languages such as a program constructed by a procedural language and an assembler language, and a program in which an object-oriented language and a procedural language are used in combination. When debugging a program module that
This was done either by applying a different debugger for each language, or by switching language modes with one debugger. In addition, even in the latter case, there is a problem that operability is not sufficient because information across languages is not shared. For example, even when it is desired to generate a break only when a certain variable area is accessed by a module constructed in a desired programming language, uniform setting is performed without considering the type of programming language. As a result, a break occurs even when a module constructed in an unintended programming language accesses the variable area, thereby reducing debugging work efficiency.

[0003]

As described above, conventionally, when debugging a program module composed of two or more types of programming languages, a different debugger is applied for each language, or one debugger is used. It is implemented by switching the language mode and using it.
Even in the latter case, there is a problem that the operability is not sufficient because information across languages is not shared.

The present invention has been made in view of the above circumstances, and recognizes information that can be shared between different programming languages, and realizes an efficient debugging by managing language switching and a debugging apparatus. The aim is to provide a method.

[0005]

SUMMARY OF THE INVENTION A debugging device according to the present invention is a debugging device for debugging a program constructed in a plurality of types of programming languages, wherein a watch point, which is an area of a predetermined variable, is accessed. In a debugging device having a watchpoint function to obtain control at the time, a watchpoint table holding watchpoint information indicating the watchpoint for each programming language, and when a programming language is switched during execution of the program, Watchpoint information corresponding to a new programming language is detected from the watchpoint table, and watchpoint setting means for resetting the watchpoint in accordance with the read watchpoint information is provided. Characterized in that it comprises.

In the debug device of the present invention, watchpoints (areas of variables for monitoring access) are managed for each programming language, and when a switching of the programming language occurs in a program being executed,
Set watchpoints for the new programming language. Therefore, it is not necessary to force the user to perform an operation corresponding to each programming language, and the watchpoint set for one programming language does not act on another programming language. An efficient and operable debugging environment can be provided for a program constructed in a programming language.

[0007] The determination of the switching of the programming language is performed, for example, by setting a hidden break point which is not related to the user in all entry sections included in the program,
When control is transferred by this breakpoint, the programming language of the calling object is compared with the programming language of the called object, and when there is a mismatch, it is determined that the programming language has been switched. I just need. The shaded gray point is determined by, for example, adding external reference information such as a function call or a function pointer to the symbol information of each object as debug information by a linker, and setting based on the external reference information. I just need. Furthermore, the recognition of the programming language may be performed based on the language identification information, for example, by adding language identification information corresponding to each entry to the symbol information of each object by a compiler.

[0008] A debugging device according to the present invention is a debugging device for debugging a program constructed in a plurality of types of programming languages, and controls when a watchpoint which is a region of a variable designated in advance is accessed. In a debugging device having a watchpoint function to acquire, setting means for setting a programming language to be debugged, and when the control is acquired by the watchpoint function, a programming language of an object being executed and set by the setting means. Determination means for determining whether or not the programming languages match, and control return means for promptly returning the acquired control when the determination results of the determination means do not match. I do.

In the debugging device of the present invention, which programming language is to be debugged, the programming language to be debugged is managed, and when control is transferred by a watchpoint,
The programming language of the object being executed is compared with the programming language to be debugged, and the control acquired when there is a mismatch is promptly returned. As a result, a break caused by an unintended object does not occur, so that efficient debugging is realized.

Further, according to the debugging apparatus of the present invention, in a debugging apparatus having a break function for acquiring control when a preset condition is met, a character string for setting the condition can be expressed in any programming language. And a break condition setting means for setting the condition based on a conditional expression of a programming language determined by the judgment means.

In the debugging apparatus of the present invention, it is determined which character string for setting a break condition is written in which programming language, and the character string is read in accordance with the result of the determination to set the condition. Therefore, the user can set the conditions in a familiar programming language without being aware of the type of the programming language of the object to be debugged, so that the operability can be drastically improved.

[0012]

Embodiments of the present invention will be described below with reference to the drawings. FIG. 1 shows functional blocks for implementing the present invention. The present invention is intended to make more efficient use of the watchpoint function. The watchpoint function referred to here is a debugger that interrupts program execution when a program accesses a predetermined variable. Function to transfer control to
This allows the user to detect an unexpected memory access.

Generally, in the operation (command) of the debugger, for example, a designation such as a watch var (break when writing to a variable var) is specified. Now, A
Suppose you specify this for a language. And B
In the language, a variable name corresponding to var is var '. In this case, if writing to var 'occurs in the B language, a break will occur.

If the user intends to debug only the A language, an unnecessary break will occur. In other words, in the B language, a watchpoint is not set or another variable is set. If the user is not interested in var ', this becomes a problem. Therefore, the present invention is characterized by proposing a mechanism for preventing a break from occurring in var '. It should be noted that the implementation for the watchpoint process is implemented by performing step execution internally in software when there is support by hardware (specifying an exception occurrence condition in the “watchpoint register”). And sometimes
Either can be applied, but the former case will be described here.

First, the switching of the language type is checked using the breakpoint function as follows. Here, the breakpoint function refers to a function of interrupting the execution of the program and transferring control to the debugger when the program executes a preset step.

The compiler 11 reads the source program stored in the source program file 21 and compiles it. When outputting a single object, which is the result of compilation, to the object file 22, the entry defined in each object is defined. Is included in the symbol information of the object (a description in a different language may be included in the same compilation unit).

On the other hand, the linker 12 reads a single object from the object file 22 and executes a link, and when outputting an execution load module as a link result to the program execution file 23, a function call, a function pointer, or the like in each object. Is added to the symbol information of the object as debug information.

The debugger 14 refers to the “external reference information” and sets a hidden break point in all the corresponding entry portions in the execution module 24 arranged on the memory 3 by the loader 13.

If a break occurs during execution of the program, the debugger 14 checks whether it is a normal breakpoint specified by the user. Otherwise, if it is the above-mentioned shadow breakpoint, there is a possibility of language switching, so refer to "language identification information" to see if the jump destination is an entry in the same language as the previous programming language Find out. If not, the debugger 14 determines that language switching has occurred, and sets the watchpoint table 1
41, the watchpoint corresponding to the programming language of the jump destination is read out, and the watchpoint register 2
Execute the reset of. The CPU 1 transfers control to the debugger 14 when an access to the area indicated by the value stored in the watchpoint register 2 occurs.

FIG. 2 shows the flow of the breakpoint processing of the present invention. When a break occurs, the debugger 14 determines whether the breakpoint is a user-specified breakpoint or the above-described shadow breakpoint (step A1 and step A3). Y in step A1),
Execute normal breakpoint processing (step A
2). On the other hand, if it is a shadow breakpoint (Y in step A3), the debugger 14 checks the language type of the jump destination from the symbol information (step A5) and determines whether or not it is the same as the current language type (step A6). . If the language types are the same (step A6)
Y), it is determined that language switching has not occurred, and the process returns to the user program (step A7). On the other hand, if the language types are different (N in step A6), it is determined that language switching has occurred, and the watchpoint register 2 is switched (step A8).

FIG. 3 shows the flow of the switching process of the watchpoint register 2 of the present invention. First, the debugger 14 stores the value stored in the watchpoint register 2 in the memory 3 (Step B1). Next, the debugger 14 determines whether a watchpoint has been set in the new language type (step B2).
If a watchpoint has been set (step B2
(Y), after restoring the watchpoint information corresponding to the new language type in the watchpoint register 2 (step B3), the debugger 14 returns control to the user program (step B4).

On the other hand, if no watchpoint has been set (N in step B2), the debugger 14
Returns the control to the user program after clearing the watchpoint register 2 (step B5) (step B6).

As a result, it is possible to set a watchpoint individually for each programming language, so that efficient debugging is realized, and the operability is dramatically improved.

Next, a description will be given of the principle of operation when the debugger 14 automatically determines which language grammar the conditional expression input by the user uses and performs debugger processing according to each language.

For example, let func be a function written in the A language. If break func ((cond ab)) is specified, a break occurs only when (cond ab) is true when the execution of the program is transferred to func. Here, (cond ab) is assumed to be an expression written in the B language. That is, the present invention is characterized by proposing a method that enables a break condition to be designated by a desired programming language without being restricted to a programming language to be debugged.

FIG. 4 shows an operation procedure of the debugger 14 at this time. In this case, the conditional expression is analyzed by the A language parser and the B language parser, and when only one of them can be analyzed, it is determined that the condition is related to the language. On the other hand, a selection process is to be performed.

The debugger 14 first determines whether the conditional expression conforms to the A language (step C1). If the conditional expression does not conform (N in step C1), the debugger 14 further determines whether the conditional expression conforms to the B language. A determination is made (step C2). If the language does not conform to the B language (N in step C2), the debugger 14 displays an error (step C2).
3). When the conditional expression conforms to the B language (Y in step C2), the conditional expression is described in the B language (step C4), and a break setting is executed.

On the other hand, even when the conditional expression conforms to the A language (Y in step C1), the debugger 14 further determines whether the conditional expression conforms to the B language (step C1).
5). Then, if they do not match (step C5)
N), this conditional expression is described in the A language (step C6), and a break setting is executed. Note that B
If it is determined that the language is compatible (step C5)
Y), prompting the operator to make a selection (step C7).

Thus, the user can always set conditions in a desired programming language, and the usability is improved. In the above-described embodiment, an example has been described in which a watchpoint is managed for each programming language and a watchpoint corresponding to a new programming language is reset when language switching occurs. Only set,
It is also effective to select which programming language is to be debugged. In this case, the debugger 14
Determines whether the target programming language is the same as the selected programming language when a break occurs due to a watchpoint, and if not, returns control to the program promptly, allowing only the intended programming language Is realized, and the efficiency of debugging a program in which two or more types of programming languages are mixed can be improved.

[0030]

As described in detail above, according to the present invention, watchpoints are managed for each programming language, and when a programming language is switched, a watchpoint corresponding to a new programming language is reset. Therefore, debugging corresponding to each programming language can be performed, and an efficient and operable debugging environment can be provided for a program constructed in a plurality of types of programming languages.

In addition, it is determined whether the character string for setting the break condition is written in any programming language, and the condition is set according to the result of the determination. Therefore, the user always sets the condition in the desired programming language. Can be performed, and operability can be improved.

[Brief description of the drawings]

FIG. 1 is a diagram showing functional blocks for implementing the present invention.

FIG. 2 is a flowchart showing a flow of a breakpoint process according to the present invention.

FIG. 3 is a flowchart showing a flow of a watchpoint register switching process according to the present invention;

FIG. 4 is a flowchart showing an operation procedure when the debugger of the present invention recognizes a language in which a conditional expression is described and sets conditions.

[Explanation of symbols]

 DESCRIPTION OF SYMBOLS 1 ... CPU 2 ... Watchpoint register 3 ... Memory 11 ... Compiler 12 ... Linker 13 ... Loader 14 ... Debugger 141 ... Watchpoint table 21 ... Source program file 22 ... Object file 23 ... Program execution file

Claims (10)

[Claims] 1. A debugging device for debugging a program constructed in a plurality of types of programming languages, the device having a watchpoint function for acquiring control when a watchpoint which is an area of a variable specified in advance is accessed. In the debugging device, a watchpoint table holding watchpoint information indicating the watchpoint for each programming language, and when the programming language is changed during execution of the program, the fact is detected and a new programming language is supported. A watch point setting means for reading watch point information to be set from the watch point table and resetting the watch point according to the read watch point information. 2. A breakpoint function for acquiring control when a predetermined step is executed, wherein the watchpoint setting means is different from a first breakpoint set by a user at an arbitrary position. Breakpoint setting means for setting a second breakpoint in all of the entry sections included in the program; and when control is acquired by the second breakpoint, a breakpoint of the calling object is called a programming language of the calling object. 2. The debugging device according to claim 1, further comprising: a detection unit configured to detect a switching of the programming language by comparing with the programming language. 3. The breakpoint setting means includes means for setting the second breakpoint based on external reference information included in symbol information held by each object, and the detection means includes: 3. The debugging device according to claim 2, further comprising means for detecting a switching of a programming language based on language identification information corresponding to each entry included in the held symbol information. 4. The debugging device according to claim 3, wherein the external reference information is stored in the symbol information by a linker, and the language identification information is stored in the symbol information by a compiler. 5. A debugging device for debugging a program constructed in a plurality of types of programming languages, the device having a watchpoint function for acquiring control when a watchpoint which is an area of a variable designated in advance is accessed. In the debugging device, setting means for setting a programming language to be debugged, and when control is obtained by the watchpoint function,
Determining means for determining whether the programming language of the object being executed matches the programming language set by the setting means; and promptly returning the acquired control when the determination results of the determining means do not match. And a control returning means. 6. The method according to claim 1, wherein the determination unit includes a unit for acquiring a programming language of the object being executed based on language identification information corresponding to each entry included in the symbol information held by each object. The debugging device according to claim 5. 7. The debugging device according to claim 6, wherein the language identification information is stored in the symbol information by a compiler. 8. A debugging device having a break function for acquiring control when a preset condition is met, and determining in which programming language a character string for setting the condition is written. A debugging device comprising: a determination unit; and a break condition setting unit that sets the condition based on a conditional expression of a programming language determined by the determination unit. 9. The debugging device according to claim 8, wherein the break condition setting means can input a character string for setting the condition in a programming language other than a programming language of an object to be debugged. apparatus. 10. A debugging device for debugging a program constructed in a plurality of types of programming languages,
In a debugging method applied to a debugging device having a watchpoint function for acquiring control when a watchpoint that is an area of a previously specified variable is accessed, watchpoint information indicating the watchpoint is provided for each of the programming languages. Holding, when the programming language is changed during the execution of the program, the fact is detected, and the watchpoint is reset according to the watchpoint information corresponding to the held new programming language. How to debug.