JPH04123144A - Debuging device - Google Patents

Abstract

PURPOSE:To constitute the device so that a system call having an interface to an OS on a different OS can be executed on the own OS by setting the execution of a pseudo operation by a program, based on state information managed by a table, and also, outputting the state information of the table to the outside by a command from outside. CONSTITUTION:When 'create-task' is issued from a program stored in a program storage part 2, the control is migrated to an interface analyzing part 5. The interface analyzing part 5 analyzes parameter information and counts the number of times of calls, and in this case, when a command from an operator is received by an execution control part 9 through an input device 3, the contents corresponding to the command are displayed on a display device 4. Subsequently, a simulation of 'create-task' is executed in a system call simulating part 6, and a necessary simulation result is written in a resource state management table 7. In such a way, a program using a system call having an interface to a target OS can be operated on the cross environment.

Description

[Detailed description of the invention]

[Object of the invention] (Industrial application field) The present invention is directed to an operating system
The present invention relates to a debugging device that pseudo-executes a program having an interface with . (Prior Art) Conventionally, a program using a system call having an interface with O8 does not operate as it is in a different cross environment of O8, and is difficult to debug. (Problem to be solved by the invention) Therefore, in order to run a program, it is necessary to replace the system call with a different O8 system call or change the parameter in the place where a system call that has an interface with O8 is referenced. Also,
There is a problem in that if the system call does not exist, a new function must be created. The present invention has been made in view of the above circumstances, and
An object of the present invention is to provide a debugging device that can pseudo-execute a program using a system call having an interface with an O8 on its own O8. [Structure of the Invention] (Means and Effects for Solving the Problem) In order to achieve the above object, the present invention provides a simulating means for pseudo-executing the operation of a program having an interface with an operating system on a cross environment. and a table for managing state information associated with the operation of the above program, and controlling the execution of pseudo operations by the above program based on the state information managed in this table, and controlling the execution of the above table by commands input from the outside. Since the configuration is equipped with a human interface unit that outputs status information to the outside, system calls that have an interface with O8 can be executed on the own O8 on a different O8 (Example) Hereinafter, one embodiment of the present invention will be described with reference to the drawings. FIG. 1 is a block diagram showing the configuration of an embodiment of the present invention.
As shown in the figure, the debug device l receives a system call, for example, an O
8 system call “Create-1ask
' is issued, the program stored in the program storage unit 2 is exchanged, and the data in the debug device 1 is transferred to an output device such as a CRT by a command input from the input device 3 such as a keyboard. Output to 4. Further, the debug device 1 includes an interface analysis section 5,
It consists of a system call simulator 6, a resource status management table group 7, a hardware simulator 8, and an execution control unit 9, each of which is configured as follows and has an interface with the O8 on a different O8. Executes the system call on its own O8. creale-- which has an interface with O8 during the execution of the program stored in the program storage section 2.
When a system call such as "1ask" is executed, control is transferred to the interface analysis section 5 which becomes the interface, and the interface analysis section 5 analyzes the parameters included in the program output from the program storage section 2 and determines the purpose. In addition, the interface analysis unit 5 counts the parameter information and the number of calls when it is called, and holds the count information, and this held information is used by the system call simulator 6 and the execution It is output to the control unit 9, and is also output to the display unit 4, which is made of a CRT or the like, via the execution control unit 9 according to the command input by the operator from the input device 3, and is visually displayed.
a module 6a that simulates “e-1ask” and a module 8b that simulates other system calls;
6c, . . . , and simulates the operation for the system call called by the system call simulator 6. At that time, if necessary, data is written to the corresponding management table of the resource status management table section 7 that holds the status of resources in this environment, and conversely, the data written in the management table is read and used for simulation. Alternatively, it is linked to a hardware simulator 8 that simulates the operation of physical resources and components. In addition, the resource status management table unit 7 holds resource status information necessary for simulating operations in response to system calls in the system call simulator 6, and also holds a management table used within the O8. do. For example, the task state management table 7a, memory state management table 7b, ..., and other O8 internal resource management tables 7n are included, and since these tables are global within the debugging device, system call numbers cannot be simulated. It is directly accessed (read and written) by the unit 6, hardware simulation unit 8, and execution control unit 9. From the operator, the execution control unit 9
accessed through the human cost interface included in the . Furthermore, the hardware simulation unit 8 is related to the system call fist simulation unit 6, and the debugging equipment fi
It simulates the hardware necessary for the O8 that is simulated by I, such as the state transition of each hardware component and the simulation of the I10 device. The results of the simulation etc. are written into the corresponding management table of the resource status management table section 7. Each component of the hardware component is modeled as an object, and simulation is performed by interrogating this object. In addition, for real-time problems, the simulation time can be registered in advance in a database, and the execution time between braking points can be calculated or set by conversation with the operator. Even if this object part is not realized, a pseudo simulation can be performed by accessing the corresponding management table of the resource status management table part 7 interactively with the operator using the execution control part 9. The execution control section 9 is a section that controls the entire debugging device t, and includes an operator, an input section 3, and a display section 4.
It includes a human interface that allows you to work interactively through the system, and allows you to check system parameters, call counts, and debug execution control. The debugging device 1 configured as described above is provided as a library, and the debugging device 1 can operate by linking with an interface that calls the interface analysis section 5 during debugging. Next, regarding the operation of one embodiment of the present invention having the above configuration,
O8 system call “create-Lask”
” is issued. From the program stored in the program storage unit 2,
8 is issued, control is transferred to the interface analysis unit 5.The interface analysis unit 5 analyzes the parameter information and counts the number of calls, but at this time, the command from the operator is When the command is received by the execution control unit 9 through the input device 3, the content corresponding to the command is displayed on the display device 4.
For example, parameter information and number of calls are displayed. Next, “cr” in the system call simulation unit 6
Create-task'' is simulated by the module 6a that simulates eat-tastc II, and the simulation results necessary for the task status management table 7a, memory status management table 7b, etc. held in the resource status management table 7 are generated. In addition, hardware resource simulation is performed by the hardware air simulator 8, but even if the hardware simulator 8 is not available, the execution control unit 9 creates the resource status management table through interaction with the operator. A pseudo simulation is performed by accessing the corresponding management table in section 7. It should be noted that the present invention is not limited to the above-mentioned embodiments, and it goes without saying that various modifications can be made without departing from the gist of the present invention. It is.

【Effect of the invention】

As detailed above, according to the debugging device of the present invention,
A program using a system call that interfaces with the target O8 can be operated in a cross environment. Furthermore, debugging can be performed even when a dedicated debugger is not available, and program development efficiency can be improved. Furthermore, by creating the debugging device of the present invention in a commonly used language that runs on different computer systems, it is possible to provide a similar debugging environment and reduce the burden on program developers.

[Brief explanation of drawings]

FIG. 1 is a block diagram showing the configuration of an embodiment of the present invention. 6... System call simulation unit (simulation means), 7... Resource status management table (table), 9...
Execution control unit (human interface unit). Agent Patent Attorney Norio Ogo

Claims (1)

[Claims] A simulation means for pseudo-executing the operation of a program having an interface with an operating system on a cross environment, a table for managing state information accompanying the operation of the program, and a table based on the state information managed in the table. A debugging device comprising: a human interface unit that controls the execution of pseudo operations by the program and outputs status information of the table to the outside in response to commands input from the outside.