JP3372106B2 - Program debug device - Google Patents

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to an improvement of a debugging device for supporting program debugging (defect removal) work, and more particularly to a device suitable for an object-oriented program.

[0002]

2. Description of the Related Art Since a computer program is a set of complicated data processing procedures, it is possible to completely prevent the occurrence of errors in the program at the time of development or modification, even if the developer takes all possible measures. Virtually difficult. Therefore, in order to improve the reliability of the program, the completed program should be executed on a trial basis and
Work to remove (debugging) is required.

A device that supports this debugging work is a program debug device. This device displays the execution location in the program while executing and stopping the program to be debugged according to the user's operation.
Display execution information related to program execution (for example, register and memory contents), break (stop) program execution at a location (breakpoint) specified by the user, user instructions and execution information, etc. This function supports efficient debugging of programs by recording the execution history of.

Conventionally, a program is mainly composed of a data processing procedure, and the data to be processed is structured separately from the processing procedure and according to the processing procedure. A program that is mainly composed of such processing procedures is called a procedural program. In a procedural program, a source code (expressed in a predetermined programming language) in which each statement (description unit such as a declaration or instruction) is described Program) simply represents the data processing procedure on the computer when the program is executed.

For this reason, the conventional program debugging device displays the program being executed in units of statements and lines (in the program description),
It assisted in debugging by setting breakpoints and recording execution history. For example, a breakpoint is set by a user on a specific line in the source code, and execution of the program stops when the breakpoint is executed regardless of the execution order of each line in the program execution.

By the way, in recent years, object-oriented programming has become popular as a new software development method. Here, the object-oriented programming expresses a real thing to be processed by software by an “object” which is a substance on the software, and the information about the real thing and a processing procedure for the information are respectively referred to as the object. This is a method of defining the data (attribute) that constitutes it and the processing procedure (for example, "operation function") for this data.

A program based on such a method is called an object-oriented program. In an object-oriented program, a plurality of objects corresponding to a real thing perform a cooperative operation, so that information processing according to the relationship between the real things is performed. It can be easily realized on a computer. As a result, the information structure of the real thing is simulated on the software structure, and the software having a clear structure and excellent maintainability can be realized. In addition, since the contents of each module that constitutes the program can be objectively understood easily, generally, it becomes easy to form each module as a component and improve reusability.

Such object-oriented programming is performed by an object-oriented programming language such as Smalltalk or C ++, and generally an object-oriented design technique for developing a program for each module is premised.

In such object-oriented programming, a program is conceptually a set of objects, but this object is materialized on the computer for the first time when the program is executed, and the data of the object is also the memory of the computer. It can have a concrete value only when it is allocated on the area.

Therefore, also in object-oriented programming, development of a program is performed in the form of source code for convenience. However, the source code in object-oriented programming is a set of classes that express the characteristics of objects. Here, a "class" is a module that constitutes a program, and represents object data and an operation on this data. Since this "class" serves as a template for creating an object that is an entity, multiple similar objects may be created from a single class, but the objects after creation are basically Are independent of each other, and the content of data differs depending on individual objects.

In the above object-oriented programming language, in order to rationalize the programming work,
A technique called "inheritance" can be used. here,
"Inheritance" means that a class inherits data groups and operations in other classes. "Inheritance" means that the inherited class re-describes the data groups and operations of the inherited class. It means that you can have it without.

This inheritance is realized by a predetermined description in the source code. With the use of inheritance, the programming of a new class is a minimum necessary description that describes only the differences to be added to the data and operations of the existing class. Easy to finish with a lot of work.

In general, the inheriting class is called a child class, and the inherited class (source of inheritance) is called a parent class. In addition, inheritance can be performed in multiple stages, and from the perspective of a class, all classes that are the source of inheritance of the own class are called ancestor classes, such as its parent class and its parent class. Call. Similarly, from a certain class, all classes inherited from its own class, such as its child class and its child class, are called descendant classes.

Conventionally, the debugging of such an object-oriented program has also been performed by using the conventional program debugging device as described above.

[0015]

By the way, in an object-oriented program, a plurality of objects are generated based on a single class, which is a template, so that a single class may correspond to a plurality of different objects. .

For example, two objects a1 and a2 that store a character string are generated based on a class [character string] that handles a character string in general, and the object a1 has a person's name "Taro Suzuki" as a content. On the other hand, assuming that the object a2 has the error message "Error1: Disk Full", a single class [character string] corresponds to the two objects a1 and a2. In this case, if there is a bug in the processing of the name data in the operation of the program, it is efficient to focus only on the object a1 having the name as the content for debugging.

However, since the conventional debugging device as described above handles the program based on the position in the source code and does not handle it in object units, it cannot efficiently support the debugging of the object-oriented program. It was That is, the conventional program debugging apparatus has the following problems when applied to object-oriented programming as a result of not treating the program based on objects.

[1. Execution location display] Even if the execution location of a program is displayed in class units, the object that is the target of execution or operation (hereinafter referred to as "operation target") is one of the multiple objects generated from that class. It was difficult to determine if there was. For example, in the above example, class [string]
Even if is displayed as the execution location, it was difficult to determine which of the objects a1 and a2 was the operation target, so the operation content of the program was confirmed by capturing when the object a1 whose name is the content was operated. I couldn't.

[2. Content Display] Further, it is conceivable that the user desires the content display of information such as data regarding a specific object. However, since the conventional program debug device is not configured to recognize a unit called an object,
Since it was not possible to associate the class on the source code with the individual concrete object at runtime, it was difficult to display and output the content data of the specific object.

For example, when a break occurs in a certain character string operation, the data to be operated can be displayed only as the data of the class [character string]. It was not possible to know whether it was the object a1 having the content of or the object a2 having the content of the error message.

[3. Setting of Breakpoint] In addition, the setting of the breakpoint in the conventional program debug device can only be set based on the class in the source code, and the breakpoint cannot be set in the object.

For example, an object a whose name is a content
To break at 1, in the past, the breakpoint had to be set in the class [character string] that handles character strings in general. However, in this case, a break occurs not only in the object a1 having the name as a content but also in the unrelated object a2 having the error message as a content. For this reason, at the time of a break, it was necessary to confirm the object to be operated by means such as displaying the contents, and if the object a1 containing the name is not the object, restart the execution.

[4. Execution history] In the conventional program debug device,
In particular, the position in the program that was the operation target could be recorded only at the position in the source code, and it was not possible to leave information about which object was executed. Therefore, in the above example, the class [string]
Although it is possible to leave an execution history that a certain operation has been executed, it is not possible to leave information as to whether it is the object a1 having a name as a content or the object a2 having an error message as a content.

[5. Inheritance] Especially, when the class that generates the object you want to focus on in debugging inherits another class, the correspondence between the execution location in the source code and the object being executed becomes complicated, and efficient debugging is achieved. It was even more difficult.

In other words, when the conventional program debugging device is applied to an inherited object-oriented program, the name of the parent class also appears in the execution location display when the child class object is executed, making it more difficult to determine the operation target object. Met. For example, in the case where the class [string] inherits the class [array], the object a is created from the class [string], and the object b is created from the class [array], the user uses the class [string]. It is assumed that the user wants to debug by focusing on the unique object a.

In this case, in the execution point display, even when the same object a is being executed, it is displayed that the class [character string] is being executed when the part unique to the class [character string] is being executed. When the operation by the function of the class [array] is diverted to the character string, it is displayed that the class [array] is being executed when the inheritance part is executed. Moreover, the display of this class [array] is the same as when the object of the class [array] is executed as an independent object itself, and from this execution point display, the user:
The operation target object could not be determined.
In particular, when the execution location display changes from class [string] to class [array], the user can determine whether this display change is due to the change of the operation target object or the execution of the inheritance part. There wasn't.

If the data of the child class includes both the data generated from the description part specific to the child class and the data generated from the inheritance part, even if both form the same object, the data contents The display was done for each class and could not be displayed collectively for each object.

For example, the class [character string] inherits the class [array], and the data of the object a of the class [character string] is the description part specific to the class [character string] excluding the inherited part from the class [array]. And the data generated based on the inheritance part from the class [array]. In this case, in the conventional program debug device, the data inherited from the class [array] is displayed to the user as the data of the class [array] and the data specific to the class [string] is displayed to the user as the data of the class [string]. Was there. Therefore, it is difficult to debug as one unit called "object a", and it is difficult to perform efficient debugging.

Further, in order to make a break in the object of the desired class, it is necessary to set a breakpoint also in the inherited parent class, but in this case, the parent class was executed as itself. Sometimes it breaks, so it was difficult to specify the operation target object.

For example, the object a of the class [character string] which inherits the class [array] has the operation of the class [array] in addition to the operation of the class [character string]. Therefore, in order to break the object a, it is necessary to set a breakpoint not only in the operation of the class [character string] but also in the operation of the inherited class [array].

Also, one breakpoint is usually
Since only one line in the source code is specified,
If the class you want to break has multiple reference functions to be referenced from other classes, and you want to always break regardless of any reference to the object of the class, have the class It required the troublesome work of setting breakpoints for all reference functions.

Of course, even if breakpoints are provided for all reference functions of such an object class, if the reference function inherits a reference function from a class of another object, all reference functions to be inherited Also, you have to set breakpoints back to your ancestor class.

Further, when a break occurs at any of these break points, the broken object is not always the object to be broken. That is, the broken object may be an object originally generated from the ancestor class to which the breakpoint is set retroactively as described above, or may be an object of another class that inherits the ancestor class. Yes, and also possible descendants of those classes.

Also, regarding the execution history of the program,
Since the name of the parent class is included in the portion corresponding to the execution of the child class, it is more difficult to determine the operation target object.

The present invention has been proposed in order to solve the above-mentioned problems of the prior art, and its object is to provide a program debug device which performs debugging support based on an object. Another object of the present invention is to provide a program debug device that makes debugging efficient.

[0036]

In order to achieve the above object, a program debug device according to a first aspect of the invention has a plurality of classes for realizing a plurality of objects of a program to be debugged based on a source code of the program to be debugged. Class information generating means for generating class information representing the structure of a plurality of objects, and a plurality of objects during execution of the program.
For each object when each of the
Object that contains the object identification and start address
Object information generating means for generating and recording information,
According to the object information, each breakpoint
Corresponding to a specific object of the plurality of objects
Multiple as set by breakpoint address
Breakpoint setting hand to set a breakpoint
Event and the specific object of the program
Event point setting means to set the
The event points are detected by executing the program.
And an event point detecting means for issuing the event point.
Event information on the execution of the program
Event information generating means for generating information .

The invention of claim 2 is the same as that of claim 1.
In the program debug device, the object information
The reference relationship between the plurality of objects based on
And the reference relation information generating means for generating to see related information, before
Reference relation information output means for outputting reference relation information,
It is characterized by having.

The invention of claim 3 is the same as that of claim 1.
In the program debug device, the break point
The setting means corresponds to one of the plurality of classes,
Breakpoint addresses at locations within multiple objects
It is characterized in that it is configured to set the space.

The invention of claim 4 is the same as that of claim 1.
In the program debug device, before the program
Corresponding to the specific object in the source code
Based on the distinguished name
Has a user interface for inputting and outputting group information
It is characterized by

The invention of claim 5 is the same as that of claim 4.
In the program debug device, the specific object
A reservation hand that reserves a debug operation using the distinguished name of
Refer to the column and the reserved identifier of the specific object
If possible, the operations reserved for this object
A reservation execution means for automatically executing a work,
Characterize.

According to a sixth aspect of the present invention, in the program debug device according to the first aspect, the event point setting means is a member related to each public member of the specific object.
An event point is set by a number , and the event point is set by each public member function of each public object in the plurality of objects included in the specific object.

The invention according to claim 7 is the program debug device according to claim 1, wherein each of the breakpoints is a first breakpoint address of the public member function of the specific object. Each public message of the parent class of the specific object
The second breakpoint address Nba functions, and the public member functions of at least one public object in said plurality of objects included in a specific object
A plurality of breakpoints as set by a number of third breakpoint addresses.

Further, the invention of claim 8 is the program debug device according to claim 1, wherein the object information generating means is generated by which other object among the plurality of objects .
It is characterized in that it is configured to record or .

[0044] The invention of claim 9 is the program debugging device according to claim 1, wherein the other of said head address in said plurality of objects of the specific object
It further comprises means for tracking access right information by tracking when and to which object of the.

According to a tenth aspect of the present invention, in the program debug apparatus according to the ninth aspect, the breakpoint setting means uses the access right information to perform the plurality of operations.
It is characterized in that it is configured to be able to set breakpoints of .

According to the eleventh aspect of the present invention, in the program debug device according to the first aspect, regardless of which object of the plurality of objects refers to one of the breakpoint addresses, the break point Breaking means for breaking the execution of the program at the point address and the break point address
The object that called
When an object that has not been set, and resuming means the execution of the program without user intervention, those
The object that called the breakpoint address
Is the object where the breakpoint is set
If a preparative, and further comprising means for passing control to the user.

[0047]

The present invention having the above structure has the following functions. That is, according to the invention of claim 1, class information representing a structure between classes in a program is generated, so that the structure between classes can be easily understood. Well
Also, when creating the program object, the object
Information is generated and recorded, so the state of the object
Easier to understand, object-oriented programming
Debugging in is effectively supported. Also desired
Program with breakpoints set on objects
You can stop the execution of
Debugging becomes easier. Also, as an event point
History of execution contents in the desired object set by
Can be recorded, so you can
The behavior of the ram can be tracked.

According to the invention of claim 2, the object
Since the reference relationship information indicating the reference relationship between
Not only the notable objects in the bag, but also this object
The objects that have a reference relationship with the object.
You can do the bag.

According to the invention of claim 3, the object
Break only the function or address whose operation you want to check
If you set the point, as long as the address is not executed
Program does not break. For this reason, debug
Work efficiency is improved.

Further, in the invention of claim 4, the debug operation
Input and output of various information are
Not only the object ID but also the identification name corresponding to the object
Done in. Therefore, understanding the information and entering debug operations
Power is easier and debugging is more efficient.

According to the invention of claim 5, the desired identification name
About desired debugging, such as setting breakpoints
You can reserve the operation. And it is possible to refer with the reserved identification name
When the object became capability is present, the object
The desired reserved operation is executed for the task. did
Therefore, debug operation is performed in units of the distinguished name in the source code.
In advance or at any point during debugging.
Can about This automates debug operations and improves
The efficiency is improved.

In the invention of claim 6, the event point is
Are also set as members of the parent class of the particular object.
When the relevant member is referenced, the operation target is specified
Since it is judged whether it is a object, it is object-oriented
Even if the inheritance in programming is done,
Event recording for each object is possible.

According to the invention of claim 7, the break point is
Are also set as members of the parent class of the particular object.
When the relevant member is referenced, the operation target is specified
Since it is judged whether it is a object, it is object-oriented
Even if the inheritance in programming is done,
Breaks can be made in object units.

In the invention of claim 8, the side to be generated
Between the object and the object that creates it
Since the relationship is recorded as information,
It is easy to know where the first access right to
it can.

According to the invention of claim 9, a certain object is
Access to other objects is transferred to other objects
Even if the
It

According to the tenth aspect of the invention, the object is
Breakpoints using access rights information for
Can be set efficiently.

According to the eleventh aspect of the invention, the break point
When an address is detected, the program is provisionally
To stop the execution at the breakpoint you set
Automatically break control to the user during a break
Therefore, at the time of a break, the user can
Without performing the備操operation, as it is open the essential debug
You can start. If you don't need a break
Can resume program execution without user intervention.
By, the program stop time can be shortened as much as possible.
it can. Therefore, the efficiency of debugging work is further improved.
can do.

[0058]

Embodiments of the present invention will now be specifically described with reference to the drawings. The following embodiments are realized on a computer, and each function of the embodiments is realized by controlling this computer by a predetermined procedure (program).

Each "means" in this specification is a conceptual one corresponding to each function of the embodiment, and does not necessarily correspond to a specific hardware or software routine on a one-to-one basis. For example, the same hardware element may be one means when executing one instruction and another when executing another instruction. Also, one means
It may be realized by only one instruction, or may be realized by a large number of instructions.

Therefore, in this specification, the embodiments are described by assuming virtual circuit blocks (means) having each function of the embodiments. However, use of a computer is an example, and all or part of the functions of the present invention may be realized on an electronic circuit such as a custom chip (dedicated integrated circuit) if possible.

The computer used in the embodiment generally has a CPU and a main memory (main memory device) including a RAM (random read / write memory element). The computer may be of any size, such as a microcomputer, a personal computer, a small computer, a workstation, or a mainframe.

The hardware of the computer is typically an input device such as a keyboard and a mouse, an external storage device such as a hard disk device, and a CRT.
It includes an output device such as a display device and a printer printer, and necessary input / output control circuits.

However, the hardware configuration of the computer is arbitrary, and as long as the present invention can be implemented, some of the above components may be added / changed / excluded. For example, the embodiments may be realized on a computer network in which a plurality of computers are connected. Also, the type of CPU is arbitrary, and multiple CPUs can be used simultaneously or a single CP can be used.
U may be used for time sharing (time division), and a plurality of processes may be simultaneously performed in parallel. In addition, other input devices (for example, a pointing device such as a touch panel, a light pen, and a trackball, an image input device such as a digitizer, an image reading device, a video camera, a voice recognition device, and various sensors) may be used. In addition, another external storage device (for example, floppy disk device / RA
M card device, magnetic tape device, optical disk device, magneto-optical disk device, bubble memory device, flash memory, etc.) may be used. Further, another output device (for example, a liquid crystal display device, a plasma display device, a video projector, an LED display device, a sound generation circuit, a voice synthesis circuit, etc.) may be used.

As a software configuration for implementing the embodiment in the computer, typically, an application program for implementing each function of the embodiment is executed on an OS (operating system). Embodiments are possible. In addition, as a mode of a program for realizing the embodiment, a machine language compiled (translated) from a high-level language or an assembler is typically considered. However, the software configuration of the computer is also free, and the software configuration may be changed as long as the present invention can be implemented. For example, it is not always necessary to use the OS, the expression format of the program is free, and an interpreter (sequential interpretation execution type) language such as BASIC may be used.

The program can be stored in any manner, and may be stored in a ROM (read-only memory), or stored in an external storage device such as a hard disk drive when the computer is started or when the computer is started. It may be loaded into the main memory at the start of processing. Alternatively, the program may be divided into a plurality of parts and stored in an external storage device, and only the necessary modules may be loaded onto the main memory at any time according to the processing content. Further, each part of the program may be stored in a different manner.

Each step of the procedure shown in the embodiment is
The execution order may be changed or parallel processing may be performed as long as the object of the present invention can be achieved. Also, the steps may be performed in a different order each time. Such an order change can be realized by a menu-type interface method, such as a user selecting an executable process.

The "input" in this specification includes not only the original input of information but also other processing closely related to the input of information. Such processing is, for example, echo back or correction / editing of input contents. In addition, "output" in this specification includes not only the original output of information but also other processing closely related to the output of information. Such processing is, for example, input of a range to be output or an instruction for screen scrolling. It should be noted that input and output may be realized by an integrated operation by an interactive input / output procedure, and processing such as selection, designation, and specification may be performed by such an integrated operation.

All events outside the computer are
Inside the computer, it is processed as data such as parameters representing the event. The data (information) and the data storage means in this specification may exist in any form on the computer. For example, the data may be stored on any hardware element (for example, a main storage device / an external storage device / a CPU register or a cache memory). Further, the data retention mode is also free. For example, the data is not only retained in the file format, but may be realized by directly accessing a storage device such as a memory or a disk by a physical address. In addition, the expression format of the data is arbitrary, and for example, the unit of the code representing the character string may be a character unit or a word unit. Further, the length of the data holding time is arbitrary, and it may be held only for a necessary time and then deleted. Information that is not changed for the time being, such as dictionary data, may be stored in the ROM.

Further, reference to specific information in this specification is a confirmation, and does not deny the existence of obvious information that is not mentioned. For example, when referring to a certain file on the disc, the existence of FAT (file allocation table) and directory is omitted as an obvious matter. In the operation of the present invention, general information necessary for the operation, such as various pointers, counters, flags,
Parameters, buffers, etc. are used as appropriate.

The information required by each part of the embodiment for processing is obtained from the other part holding the information unless otherwise specified. Such acquisition of information can be realized, for example, by accessing a variable or memory that stores the information. Information can be erased / erased by not actually deleting the content itself of the information from the storage area but by modifying the information such as setting an erase flag.

[1. First Example] [1-1. Configuration of First Embodiment] An object of the first embodiment is to provide a program debug device which performs debugging support based on an object. FIG. 1 is a block diagram showing the configuration of the first embodiment. That is, the program debugging device of the first embodiment, as shown in this figure, has a keyboard 1 and a mouse 2
A floppy disk device 3, a display device 4, and a processing unit 5 for processing information. Of these, processing unit 5
Has a user interface unit 6. Although not shown, the user interface unit 6 is composed of a combination of an I / O control circuit and an input / output procedure using a menu type or interactive interface method. Through, it is possible to receive information output from each block and input desired information and instructions to a desired block. The user interface unit 6 corresponds to the object information output unit, the reference relation information output unit, and the event information output unit.

Further, the program debugging apparatus of the first embodiment has a source code storage unit 7 for storing the source code of the program to be debugged and a class information generation unit 8 for generating class information representing a structure between classes in the program. (Corresponding to the class information generating means),
And a class information storage unit 9 for storing the class information.

Further, the program debug device of the first embodiment includes a debug information storage section 10 for storing debug information of a debug target program, a load module storage section 11 for storing a load module of the program,
An execution unit 12 (corresponding to the execution unit) that executes a load module of the program and generates execution information regarding execution contents, and an object based on the class information and the execution information during execution of the program. An object information generation unit 13 (corresponding to the object information generation unit) that generates object information related to the generation and disappearance of the object and an object information storage unit 14 that stores the object information.

Further, the program debug apparatus of the first embodiment generates the reference relation information indicating the reference relation between the respective objects on the basis of the object information, the reference relation information generating section 15 (in the reference relation information generating means). Equivalent) and a desired object related to the program and a breakpoint setting unit 16 (the event point setting means and the breakpoint setting means) for setting a breakpoint and an event point at a desired position in the object. Corresponding to the above), a break point storage unit 17 that stores information indicating the break point and the event point, and a break processing unit 18 that breaks the execution of the program at the break point and the event point. Ibe And a ones) and corresponds to preparative point detection means.

The program debug device of the first embodiment also generates an event information generating section 19 (corresponding to the above-mentioned event information generating means) for generating event information relating to a predetermined execution content at the event point when a break occurs at the event point. And an event information storage unit 20 (corresponding to the event information storage means) that stores the event information.

[1-2. Operation of First Embodiment] Debugging in the program debug device of the first embodiment having the above configuration is performed as follows.

[1-2-1. Schematic Operation] FIG. 2 is a conceptual diagram showing a mode of debugging in the program debug device of the first embodiment. That is, in the program debug device of the first embodiment, the program to be debugged is executed after the breakpoint is set, and when a break (stop) in program execution occurs at the breakpoint, the information such as the source code is displayed for debugging. It can be performed. Further, in the program debug device of the first embodiment, the debug target program may be executed step by step and the information such as the source code may be displayed for each step. The operation of the program debug device according to the first embodiment will be specifically described below.

[1-2-2. Data Input] Prior to debugging, the user compiles a source code of a program to be debugged by a compiler to generate a load module (usually a machine language executable program) and debug information. Here, the debug information consists of a comparison table of statements (description units) or symbol names (data names, function names, label names, etc.) in the source code and addresses (memory addresses) in the load module. It is a thing. This debug information can be obtained by a debug information generation function that a known compiler generally has. The debug information includes an identification name that specifies object generation in the source code.

Next, the user inputs the source code, the debug information and the load module through the disk device 3 and the user interface unit 6, which are respectively the source code storage unit 7 and the debug information storage unit 1.
0. Stored in the load module storage unit 11.

[1-2-3. Extraction of Class Information] Next, the class information generation unit 8 generates class information representing the configuration of the class in the source code based on the source code, and the class information storage unit 9 stores this class information. Note that in the source code of an object-oriented programming language, since information about the structure of classes is defined in a certain format, the inclusive relationship between classes, the inheritance relationship, and the internal structure of classes (data, operations, etc.)
Information such as can be easily extracted from the source code.

Here, FIG. 3 is a general expression format of class information in the program debugging device of the first embodiment. For each class, a class name or parent class name is followed by a member of an object of the class. It is shown. Here, the "member" is each data (member data) forming an object and an operation on each of these data. It should be noted that the member data is referred to as a “member object” in the present specification because it can be considered as another object that an object has as a member, however simple the data may be. Further, an operation on a member object is referred to as a "member function" in this specification. A member of such an object shares a fate with the object, is created by the creation of the object, and disappears when the object disappears.

Further, the members of the object can be classified into public members and private members. here,
"Public members" are members that can be referenced by other objects, and "private members" are members that cannot be referenced (hidden) by other objects. By the way, as described above, there are types of members, that is, a member object and a member function. If this type is combined with a type of public / private, the members of the object become “public member object” and “private”. It can be classified into four types of "member object", "public member function", and "private member function".

Next, FIG. 4 shows an example of concrete class information expressed in conformity with the format of FIG. In this figure,
Asterisk (*) added to the member object name
Is a symbol indicating a pointer type object, and the pointer type object is data for each object to refer to another object that is not a member of itself. This object is called "pointer type" because it points (points) to another object.
Specifically, the data contained in the pointer type object is an address of a portion of the address of the load module corresponding to another object referred to by the object.

That is, in an object-oriented program, each object executes a certain operation on another object through this pointer type object, thereby realizing a cooperative operation among a plurality of objects and operating the entire program. To do.

Note that, in FIG. 3, "class name and variable name that can refer to this class" is the reverse of the above, and is the name of another class or variable that holds the class as a member object or pointer type object. Is.

[1-2-4. Setting Breakpoints to Creation / Extinction Function] Subsequently, the breakpoint setting unit 16 performs a function for creating an object (referred to as “constructor” or “generation function” in this specification) and a function for extinguishing (book). In the specification, a system breakpoint is set to "annihilator" or "annihilation function". Here, a "system breakpoint" is similar to a breakpoint, but it is set regardless of the user's specification, and the specified procedure is executed when a break occurs. , When a break occurs, the state of waiting for an instruction by the user does not occur.

That is, in the process of executing a program, an object is created or deleted from a class, and specifically, the object is placed in the memory or deleted. The creation and disappearance of such an object is performed by calling the constructor and the extinct child, and the fact that the user can accurately grasp this
Very important when debugging.

In the object-oriented language, since the names of the generation function and the extinction function are generally specified, it is easy to detect them. For example, in C ++,
The function having the same name as the class name is the generation function, and in another language called Eiffel, the function named "Create" corresponds to the generation function.

When a class inherits another class, the constructor and the extinct child of the parent class are also inherited in the same manner as ordinary member objects and member functions. However, at the same time, the unique constructor / annihilator defined in the child class is also executed. Therefore, at the time of object creation, all the creation functions of the ancestor class are called in addition to the creation function of the class of that type. When the object disappears, all the annihilation functions of the ancestor class as well as the disappearance functions of the class of that type are called. .

[1-2-5. Execution of Load Module] When a user gives an instruction to execute a program through the user interface unit 6, the execution unit 12 executes the program. In this instruction, the user can instruct execution of each step, and in this case, the execution of the program (break) stops at each step, and the user
Various information can be referred to from the user interface unit 6.

[1-2-6. Extraction of Object Information] When the load module is executed, the object information generation unit 13 causes the object information generation unit 13 to generate and delete objects based on the execution information (for example, the execution address and the contents of the register) related to the program execution obtained from the execution unit 12. Information is extracted and generated, and the object information storage unit 14 stores this object information. That is, as described above, since break points are set in all the constructors and the annihilators, the break processing unit 18 stops the program execution each time an object is created or deleted when the load module is executed. , Activates the object information generation unit 13. Object information generator 1
3. After recording the creation and disappearance of objects,
The execution unit 12 restarts the program execution.

Here, FIG. 5 is a flow chart showing the procedure of object information generation. That is, in this procedure, it is judged whether or not the constructor or the extinct child is called the constructor or the extinct child of the descendant class (step 51). It is recorded (step 52). That is, when an object is generated, the head of the address where the object is arranged and the identification number (ID) of the object are recorded. On the other hand, when the object disappears, the information of the disappeared object is deleted.

Subsequently, the change in the reference relationship due to the change in the object is also recorded (step 53). That is, in the case of generation, the object information of the generated object is recorded in the object information of the generated object as an object that can be referred to, and in the case of disappearance, the information of the object that has the disappearing object as the referenceable object. Delete the object that disappears from. In the program debug device of the first embodiment, when an object is created or disappears, the user is notified of that fact through the user interface unit 6 (step 5).
4).

At first, the object which can refer to an object is only the object which has generated the object, but the object which has generated the object has access right to the generated object during program execution. It may be moved to another object. In object-oriented programs, this is accomplished by a function that gives and receives addresses to the created objects. Therefore, when the execution unit 12 executes such a function, the object information generation unit 13 records the transfer of the access right.

That is, FIG. 6 is a flow chart showing the recording procedure of the access right transfer when the function of transmitting and receiving the address is executed. That is, in this procedure, when the object that called the function receives the address of the object (step 61), the object associated with the address is registered as the object that can be referred to by the object that called the function (step 62). If the object that called the function sends the address of the object (step 63), the object that called the function is registered as an object that can be referenced by the object corresponding to the sent address (step 6).
4).

FIG. 7 is a diagram showing a general format of the object information generated and recorded as described above in the program debug device of the first embodiment, and FIG. 8 is a diagram showing a concrete example of the object information. is there.

In this example, the object ID for identifying the object, the start address of the object, the class name / variable name / object I of the member object
D is registered. Further, the member object of the object and the inherited parent class object are also registered as independent objects. For example, the class Cl
As an object of ass A, “ID is 11, allocation address is 8000 0000 (Hex), and as its member object, str of string type (ID = 12), x of integer type (ID =
18) ”is registered. The String type object 12 is also registered in the class String portion at the same time.

The user can refer to the object information and the reference relation information described later by performing a predetermined operation through the interface section 6 at a desired time.

[1-2-7. Creation of Reference Relationship Information] By performing a predetermined operation through the user interface unit 6, the user can obtain reference relationship information indicating a reference relationship between objects performed using a pointer type object or a member object. That is, when the user inputs a predetermined instruction through the user interface unit 6, the reference relationship information generation unit 15 generates the reference relationship information at the time when the user inputs the instruction based on the object information and the user interface unit 6 performs the reference relationship information. Output.

The user specifies the central object in this instruction, and the reference relation information is an object that can refer to the central object, and
It is provided in a format that can be referenced by the central object. Note that not only one object may be designated and displayed, but the reference relationship of all objects may be displayed. Further, the user may be informed of the change in the reference relationship of the objects each time.

Here, FIG. 18 is a flow chart showing the procedure for generating the reference relation information. That is, in this procedure, the class that can refer to the central object and the class that can be referred to from the central object are specified based on the class information, and then the addresses of the objects corresponding to these classes are investigated based on the object information. Further, the ID of each of these objects is acquired through the execution unit 12. The address of the object includes the address pointed to by the pointer-type object that is a member object of the central object. By investigating this address, the ID of the object that can be referenced using the pointer-type object can be acquired.

Break processing and event recording for each object are performed based on various kinds of information such as execution information and reference relation information (further class information when inherited).

[1-2-8. Setting of User Breakpoint] Also, the user can set a breakpoint on an object-by-object basis. That is, when the user specifies a setting object to set a breakpoint through the user interface unit 6, the breakpoint setting unit 16 sets a breakpoint in the setting object. Needless to say, as in the conventional case, it is possible to set breakpoints effective for all objects, which specify only addresses.

The user can set a breakpoint at a desired portion of the desired object by using the breakpoint setting unit 16. That is,
In the program debug device of the first embodiment, two types of breakpoints, object type breakpoints and (object designation) address type breakpoints, can be set. Here, the "object type breakpoint" is a break point when an operation is performed on the object specified by the user, and the "address type breakpoint" is the object specified by the user and further specified by the user. It breaks only at the specified position, that is, at a specific position within a specific member function or inherited member function.

As described above, in the program debug device of the first embodiment, if a breakpoint is set only in the function or address of the object whose operation is desired to be confirmed, the program will not break unless the address is executed. Therefore, the efficiency of debugging work is improved.

When the user selects the object type,
The breakpoint setting unit 16 sets a breakpoint on all public member functions of the target class and the ancestor class of the target class. The member function of the object is
Since the member function of the ancestor class is included in addition to the class which is the type, by setting a breakpoint in all of those functions, it is possible to judge whether or not to break when referenced by any function. It can be performed. That is, in the program debug device of the first embodiment, a break point is determined by two elements, an address and an object ID, in order to realize a break for each object.

When the class of the object inherits other classes in multiple stages through the parent class, the breakpoints are set in all the public member functions of all the classes which are inherited by tracing back this inheritance relationship. Is set.

If the object to be set has a public member object, the member object is also an object that can be referred to by the object, and therefore an object type breakpoint is set for the member object. That is, when the object on the reference side holds the object as the address data of the member object, a breakpoint is set at the portion where the member object is operated. FIG. 9 is a flowchart showing an example of a schematic procedure for setting an object type breakpoint.

FIG. 10 is a flow chart showing the procedure for setting an address type break point. In this procedure, duplication of addresses and objects is checked. If it does not exist, set a breakpoint and register it. If there are duplicate addresses and the objects are different, only register the breakpoint.

FIG. 11 is a diagram showing a general format of data indicating a breakpoint, and FIG. 12 is a specific example of data indicating a breakpoint. In this example, I of the object for which an object type breakpoint is set
D (class Class A type ID = 11) and the position of the address type breakpoint set at the beginning of the member function (pr
The start address 2000 4000 (Hex) of intA () and the reference target object ID (ID = 11 etc.) are registered. Also, an object of class ClassA (ID = 1
By setting the object type breakpoint in 1), the object type breakpoint is automatically set also in the object of the class String type (ID = 12) which is the member.

[1-2-9. Setting Event Point] Further, the user can set an event point on the object through the break point setting unit 16. Here, the "event point" is a point for recording the predetermined processing content regarding the designated position, although the execution of the program is not stopped. Note that the effect of this event point at the time of execution is different from the user breakpoint, and the type and setting procedure are not different from the user breakpoint. That is, as with the user breakpoint, two types of event points, that is, an object type and an address type, can be designated, and the event points are set in the same procedure as the user breakpoint. Needless to say, it is possible to set an event point that is common to all objects and that specifies only the address.

FIG. 13 shows a general format of information designating an event point, and FIG. 14 is a specific example of this information. In this example, an object type event (object ID = 12) and an address type event (object ID = 154, address 2000 3000) are registered.

[1-2-10. Break Processing] The break processing unit 18 monitors the execution address of the load module, and when it detects the address at which the breakpoint is set, it temporarily stops the execution of the program and checks whether or not the break condition is satisfied. to decide. That is, the break processing unit 18 determines, based on the class information and the execution information, whether or not the break has occurred in the object for which the breakpoint is set.

When a break point attached to the public member function of the class of the target object and the parent class of the class is detected, the execution unit 12 is in operation at the time of the break, as shown in FIG. 15 (flow chart). The ID of the object is investigated (step 15
1) If the object ID is registered as a break target (step 152), control is transferred to the user interface unit 6 while the execution is interrupted (step 153), and if it is not registered, the execution is resumed. (Step 154).

FIG. 16 (flowchart) shows the processing when the execution of the program is interrupted by the breakpoint set for the public member data. That is, in this case, first, the format of the object relating to the breakpoint is determined (step 161). That is,
If the object is an object that has access rights and is held as a member object, a break occurs (step 163) and the user interface unit 6 is activated. If the object is held as address data in an object that can be referred to, it is determined whether the address corresponds to the setting object (step 162), and if it is the setting object, a break occurs (step 163). If it is not a setting object, execution of the program is restarted (step 164).

Further, FIG. 17 shows a procedure of break processing relating to the address type break point.

[1-2-11. Recording of Event] When the break processing unit 18 detects an event point, it activates the event information generation unit 19. The event information generation unit 19 uses the execution information to generate event information such as the content of the operation on the object. Extract
It is generated and the event information storage unit 20 stores this information. After extracting the information, the event information generation unit 19
2 is started and the execution of the program is restarted.

The general format of this event information is (operation target object ID, function address). As a specific example, (154, 2000 3000) (12, 2000 331)
0) can be mentioned. In this example, the ID of the operated object, the ID of the object that tried to operate the object, and the address of the function used for the operation are recorded. That is, the event that the String type object "12" is operated by using the member function "2000 3310" is recorded.

When a plurality of types of points are set in duplicate for the same target, the break processing unit sequentially processes the processing units corresponding to the respective points in the order of system break point, event point, and user break point. to start.

[1-3. Effects of First Embodiment] As described above, according to the program debug device of the first embodiment, class information representing a structure between classes in a program is generated and output, so that the structure between classes can be understood. It will be easier. Further, in the program debug device of the first embodiment, since the object information is generated and output, it is easy to understand the state of the object. For this reason, the user can perform debugging while watching the status of the object including the generation and disappearance of the object, and the debugging focusing on the specific object becomes easy. Further, in the program debug device of the first embodiment,
Since the reference relation information indicating the reference relation between the objects is output, it is possible to obtain the information about the object having the reference relation with the object to be noted in the debugging.

Further, in the program debug device of the first embodiment, a breakpoint can be set on a desired object and the execution of the program can be stopped at the breakpoint, which facilitates debugging focusing on a specific object. Further, in the program debug device of the first embodiment, since the history of the execution contents of the desired object set as the event point can be recorded, the behavior of the program can be traced by focusing on the specific object.

Further, in the program debug device of the first embodiment, the breakpoint is set also in the member of the parent class of the setting object, and when the member is referenced, it is judged whether or not the operation target is the target object. Therefore, even if inheritance in object-oriented programming is performed, breaks can be made in object units.

As described above, according to the program debugging apparatus of the first embodiment, since the debugging support based on the object is performed, the debugging focusing on the specific object becomes easy, and the efficiency of the debugging work in the object-oriented programming is improved. improves.

[2. Second Example] It should be noted that input / output of an object such as debug operation and output of various information may be performed based on an identification name corresponding to the object in the source code. Further, a desired debug operation may be reserved by the object identification name. The program debug device of the second embodiment shows a configuration for realizing these.
An object of the embodiment is to provide a program debug device that makes the debug operation efficient.

That is, FIG. 19 is a functional block diagram showing the structure of the program debug device of the second embodiment of the program debug device. As shown in this figure, the program debug device of the second embodiment is a program debug device having a configuration substantially similar to that of the program debug device of the first embodiment, and is a reservation for reserving a desired debug operation with an object identification name. A part 21 (corresponding to the reservation unit) and a reservation execution part 22 (reservation execution) for executing an operation reserved for the object when an object that can be referred to by the reserved identification name exists. (Corresponding to the means) means.

The program debug device of the second embodiment also has a user interface 26 for inputting / outputting each object based on the identification name corresponding to the object in the source code. In such a second embodiment, the input of the debug operation and the output of various information are not limited to the ID of the object inside the system,
It is done with the distinguished name corresponding to the object. For this reason,
The information can be easily understood and the debug operation can be input easily, and the debugging can be made efficient.

[2-1. Reservation of Operation] In the program debug device according to the second embodiment, the user can reserve a desired debug operation by the object identification name by the reservation unit 21. That is, this reservation can be performed before or during execution of the program. As the identification name, the identification name in the source code of the object of interest is used. The identification name is acquired as debug information. As an operation, a desired operation such as setting a breakpoint or an event point can be freely reserved. The reservation content is held as data in a predetermined memory area.

FIG. 20 shows an example of reservation contents, in which an object is designated by a type and an identification name and operation contents are described. For example, in the second line, a String type object "zoo->c" that is a member of the cat type object.
at. An operation of setting an object type breakpoint to "name" is shown.

[2-2. Execution of Operation] When there is an object that can be referred to by the reserved identification name, the reservation execution unit 22 executes the reserved operation for the object.

As a case where the object can be referred to by the reserved identification name, typically, when the object is generated with the reserved identification name, the access right by the pointer type object is transferred to the existing object. If it becomes possible to refer to the object with the reserved distinguished name, it can be mentioned.

In order to detect these cases, the following processing is performed. That is, during the execution of the program, the break processing unit 18 detects the generation of the object and the operation of the pointer type object, and the reservation processing unit 22 detects them.
To notify. When the object is generated, the reservation execution unit 22 investigates whether or not the identification name of the object matches the reserved identification name, and if they match, executes the reserved operation for the identification name.

Further, when the pointer type object is operated, the reservation executing section 22 checks whether or not the transfer of the access right makes it possible to refer to the existing object with the reserved identification name. If it becomes possible, execute the reserved operation for the relevant identification name.

Note that these investigations are performed by using the reference relation information, execution information, source code, debug information, etc., and the actual operation is performed by specifying the object by the ID. Further, FIG. 21 shows an example of an operation procedure of the reservation executing means.

The reserved operation may be executed immediately if there is an object having the reserved identification name at the time of reservation. FIG. 22 shows an example of the operation procedure of the reservation executing means in this case.

As described above, in the program debug device of the second embodiment, it is possible to reserve a desired debug operation such as setting a breakpoint for a desired identification name regardless of whether the program is being executed or being executed. Then, when there is an object that can be referred to by the reserved identification name, the reserved operation is executed for the object. Therefore, the debugging operation is automated and the debugging is efficient.

[3. Third Example] In the present invention, various information may be displayed using a multi-window display system that displays one or more windows. By using this display system, other information related to the information displayed in a window can be sequentially called up in a new window so that various types of information can be displayed in an organically related manner and used efficiently. it can.

For example, the source code (FIG. 23), class information (FIG. 24), object information (FIG. 25), etc. are displayed for each window. Further, the operation for the displayed information such as the setting of a breakpoint is performed in a new operation window (FIG. 26).

In these windows, for example, at the time of a break, the source code relating to the breakpoint or (see FIG.
7), information on the object that has broken (FIG. 28) may be displayed. Further, as shown in FIGS. 27 and 28, it is conceivable that a part of information is highlighted by reverse display or the like.

In such a multi-window system, the corresponding source code portion may be displayed in one window and the corresponding object information may be displayed in another window (FIG. 29). Further, a breakpoint or an event point may be set in the object corresponding to the source code (FIG. 30).
Furthermore, when setting a breakpoint on an object corresponding to the source code, display multiple objects corresponding to the relevant part of the source code in another window and select the object to be set from among them. Good (Figure 31).

[4. Other Embodiments] The present invention is not limited to the above embodiments,
Since the embodiment can be freely changed, the following other examples are also included. For example, the present invention may be applied to any object oriented programming language. Also, the display format of various information such as class information and object information is free. Further, the type of the breakpoint set in the object may be either one of the object type and the address type. In addition, operation reservation and multi-window display system are not essential.

[0141]

As described above, according to the present invention, since it is possible to provide a program debugging device that supports debugging work based on objects, the efficiency and reliability of software development by object-oriented programming are improved. .

[Brief description of drawings]

FIG. 1 is a functional block diagram showing a configuration of a program debug device according to a first embodiment of the present invention.

FIG. 2 is a flowchart conceptually showing a mode of debugging work in the program debugging device in the first embodiment of the present invention.

FIG. 3 is a diagram showing a general format of class information in the program debug device according to the first embodiment of the present invention.

FIG. 4 is a specific example of class information in the program debug device according to the first embodiment of the present invention.

FIG. 5 is a flowchart showing a procedure of object information generation in the program debug device according to the first embodiment of the present invention.

FIG. 6 is a flowchart showing a procedure for generating object information when a function for transferring an object address is accessed in the program debug device according to the first embodiment of the present invention.

FIG. 7 is a diagram showing a general format of object information in the program debug device according to the first embodiment of the present invention.

FIG. 8 is a specific example of object information in the program debug device according to the first embodiment of the present invention.

FIG. 9 is a flowchart showing a procedure for setting an object type breakpoint in the program debug device according to the first embodiment of the present invention.

FIG. 10 is a flow chart showing the procedure of address type breakpoint setting in the program debug device of the first embodiment of the present invention.

FIG. 11 is a diagram showing a general format of information representing a breakpoint in the program debug device according to the first embodiment of the present invention.

FIG. 12 is a diagram showing a specific example of information indicating a breakpoint in the program debug device according to the first embodiment of the present invention.

FIG. 13 is a diagram showing a general format of information representing an event point in the program debug device according to the first embodiment of the present invention.

FIG. 14 is a diagram showing a specific example of information representing an event point in the program debug device according to the first embodiment of the present invention.

FIG. 15 is a flowchart showing a processing procedure when a break set in a public member function of an object class and its ancestor class occurs in the program debug device of the first embodiment of the present invention.

FIG. 16 is a flowchart showing a processing procedure in the case where a set break occurs when the program debugging apparatus according to the first embodiment of the present invention has a public member.

FIG. 17 is a flowchart showing a procedure of break processing related to an address type break point in the program debug device according to the first embodiment of the present invention.

FIG. 18 is a flowchart showing a procedure of reference reference information generation in the program debug device according to the first embodiment of the present invention.

FIG. 19 is a functional block diagram showing a configuration of a program debug device according to a second embodiment of the present invention.

FIG. 20 shows reserved contents in the program debug device according to the second embodiment of the present invention.

FIG. 21 is a flowchart showing an operation procedure of a reservation execution unit in the program debug device according to the second embodiment of the present invention.

FIG. 22 is a flowchart showing an operation procedure of a reservation execution section in the program debug device according to the second embodiment of the present invention.

FIG. 23 is a window display example in the program debug device according to the third embodiment of the present invention.

FIG. 24 is a display example of a window in the program debug device according to the third embodiment of the present invention.

FIG. 25 is a window display example in the program debug device according to the third embodiment of the present invention.

FIG. 26 is a window display example in the program debug device according to the third embodiment of the present invention.

FIG. 27 is a display example of a window in the program debug device according to the third embodiment of the present invention.

FIG. 28 is a display example of a window in the program debug device according to the third embodiment of the present invention.

FIG. 29 is a display example of a window in the program debug device according to the third embodiment of the present invention.

FIG. 30 is a window display example in the program debug device according to the third embodiment of the present invention.

FIG. 31 is a window display example in the program debug device according to the third embodiment of the present invention.

[Explanation of symbols]

1: Keyboard 2: Mouse 3: Floppy disk device 4: Display device 5: Processing unit 6, 26: User interface section 7: Source code storage 8: Class information generator 9: Class information storage 10: Debug information storage 11: Load module storage section 12: Execution unit 13: Object information generation unit 14: Object information storage section 15: Reference relationship information generation unit 16: Breakpoint setting section 17: Breakpoint storage 18: Break processing section 19: Event information generation unit 20: Event information storage section 21: Reservation department 22: Reservation execution unit

─────────────────────────────────────────────────── ─── Continuation of the front page (72) Inventor Tokuaki Koyama 70 Yanagimachi, Saiwai-ku, Kawasaki City, Kanagawa Stock company Toshiba Yanagimachi Plant (56) References JP-A 64-19439 (JP, A) JPA 1 -229339 (JP, A) JP-A-5-282174 (JP, A) (58) Fields investigated (Int.Cl. ⁷ , DB name) G06F 11/28 G06F 9/44

Claims (11)

(57) [Claims] 1. Class information generation means for generating, based on a source code of a program to be debugged, class information representing a structure between a plurality of classes for realizing a plurality of objects of the program, and during execution of the program. In addition, when each of the plurality of objects is generated, object information generating means for generating and recording object information including an object identification and a start address for each object, and each breakpoint according to the object information. Breakpoint setting means for setting a plurality of breakpoints so that they are set at break point addresses corresponding to specific objects of the plurality of objects, and an event point setting means for setting an event point on the specific object of the program. A program debug device comprising: a stage; event point detecting means for detecting the event point by executing the program; and event information generating means for generating event information related to the execution of the program at the event point. . 2. A reference relationship information generating unit that generates reference relationship information indicating a reference relationship between the plurality of objects based on the object information, and a reference relationship information output unit that outputs the reference relationship information. The program debugging device according to claim 1, wherein 3. The break point setting means is configured to set a break point address at a position in the plurality of objects corresponding to one of the plurality of classes. Program debug device. 4. The program according to claim 1, further comprising a user interface for inputting / outputting debug information regarding an object based on an identification name corresponding to the specific object in the source code of the program. Debug device. 5. Reserving means for reserving a debug operation using the identification name of the specific object, and a reserving operation for the object when the specific object can be referred to by the reserved identification name. 5. The program debugging device according to claim 4, further comprising a reservation execution unit that executes automatically. Wherein said event point setting means, the setting of the event points each published member functions of a particular object, each published member of each published object in the plurality of objects included in the specific object
The program debug device according to claim 1, wherein the program debug device is configured to set an event point by a function . 7. The break point setting means sets each break point to the public message of the specific object.
A first breakpoint address of a public function, a second breakpoint address of each public member function of a parent class of the particular object, and a public member of at least one public object of the plurality of objects contained in the particular object. 2. The program debug device according to claim 1, wherein the program debug device is configured to set a plurality of breakpoints as set by a third breakpoint address of the function . 8. The object information generating means determines which object in the plurality of objects is the other object.
2. The program debug device according to claim 1, wherein the program debug device is configured to record whether the object is generated by the object . 9. The other object among the plurality of objects, wherein the start address of the specific object is
2. The program debugging device according to claim 1, further comprising means for tracking access right information by tracking when the data is transferred to and from the access right information. Wherein said break point setting means, before
The plurality of breakpoints using the access right information
10. The program debug device according to claim 9, wherein the program debug device is configured to be able to set . 11. Breaking means for breaking execution of the program at the breakpoint address regardless of which of the plurality of objects referred to one of the breakpoint addresses, and the breakpoint. The object that called the address
Is an object whose breakpoint is not set.
And the object that called the breakpoint address , the method of restarting the execution of the program without user intervention.
The object where the breakpoint is set.
If it is transfected, a program debugging device according to claim 1, further comprising a means to pass control to the user.