JPH05250221A - Simulator execution system - Google Patents

Abstract

PURPOSE:To easily confirm a stack size in a program execution state and also to accurately set the stack size. CONSTITUTION:An input part 103 is provided to input the information produced by a language processing program from an input file 102 together with a simulation executing part 107 which simulates the instruction corresponding to the input of the information, an analyzing part 105 which analyzes the contents of the character strings inputted from a monitor control console 104 and set on a start row, and a control/display part 106 which controls and displays the execution of a program carried out at the part 107. Furthermore the part 107 includes a stack information detecting part 109 which detects and outputs the memory area information used by a stack in a program execution state, a stack designated value holding part 110 which holds the designated value of a stack pointer, a stack value holding part 111 which holds the stack pointer value in an instruction execution state, and a memory/register contents holding part 112 which holds the value of the stack pointer.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a simulator execution method.

[0002]

2. Description of the Related Art Generally, in developing a program,
An editor, an assembler, a compiler, a linker, and the like are used for creating, executing, and preparing for execution of a program. The editor is a tool that edits the program according to the user's specifications, and the assembler and compiler are
It is a program that translates a program written in a programming language into a language suitable for a computer. The linker is a program that combines pieces of information translated by the assembler and the compiler. However, since an error usually occurs in a program created using these, this error must be detected (hereinafter referred to as debugging). Desktop debugging and machine debugging are available as debugging methods. In the former case,
Program flow chart and program listing
This is a method of inspecting the operation of each instruction and each step of the flow chart. In the latter case, it is a method of actually executing a program to check the state of variables. This machine
An in-circuit emulator or a simulator is a typical means for debugging, but in the end, it must be debugged by an actual machine. The simulator is the target CPU or I / O on the host computer.
It is a software tool for checking the operation of a program by simulating the operation of O as software. As a general function of this simulator, the function to execute the program from the specified address, the breakpoint to stop the execution of the program when the condition set in advance is satisfied, and it is stored in the storage device. Dump to display the contents on the display, and program counter, stack
There are several functions, including traces that display pointer address values and register contents on a display.

When debugging is performed using this simulator, a computer often runs out of control due to a design problem that affects the utilization of a memory area during execution of a program. The memory area for executing a program is roughly divided into a static memory area and a dynamic memory area, and the static memory area has a data structure defined in the program by the user of the program,
Variables and constants are allocated, and the dynamic memory area is used as an area required for information relating to procedures in a program, and an area temporarily required for expression evaluation and argument transfer. It Allocation to the dynamic memory area generally includes heap allocation and stack allocation, and the size is changed when the program is executed. Therefore, when the stack is used in an area other than the area set as the stack area during the execution of the program, a stack overflow may occur, causing a runaway. In such cases, the program user can change the stack size setting, write a check routine that displays data in various places in the program, or patiently execute the program and perform tracing. The current situation is to check the contents of the stack pointer and each register one by one from the output result.

In recent years, the use of languages at a higher level than machine languages has increased with the complexity of programs.
High-level languages have the advantage that they are not dependent on any particular computer and are close to human languages, but they have the disadvantage of being incapable of fine memory management in source programs as compared to machine languages. For this reason, it is difficult to predict the memory area used by the stack during program development during program development, and this is not easy, especially when interrupt processing is taken into consideration.

When changing the stack size setting among the above-mentioned measures against program runaway, the memory area when the stack is most used cannot be discriminated at the time of execution. Actually, the stack size is roughly set in advance. In addition, in a coping method such as patiently tracing and checking the data, execute the program patiently and repeat the trace for the number of executed instructions to check the operation of the stack pointer and each register. It takes a lot of time and effort to do so.

[0006]

In the above-mentioned conventional simulator execution method, in order to confirm the stack size at the time of execution from the output result of the trace by the simulator, the program should be patiently executed. It is necessary to perform an operation of tracing the number of executed instructions and checking the contents of the stack pointer and each register one by one from the output result, which is disadvantageous in that much labor and time are required.

[0007]

A simulator execution method according to the present invention comprises a file information input section for inputting information created by a language processing program from a predetermined file,
A simulation execution unit that simulates an instruction corresponding to the input of the information, an analysis unit that analyzes the content of a character string on a startup line that is input from a predetermined monitoring and control console, and a character string by the analysis unit In the simulator execution method, which is formed by receiving at least an analysis result, controlling execution of a program in the simulation execution unit, and at least a control / display unit for displaying information including a simulation execution state, The stack information detection unit that detects and outputs the memory area information used by the stack when the simulation execution unit executes the program, the stack specified value holding unit that holds the specified value of the stack pointer, and the stack A stack value holding unit that holds a pointer value is provided in the simulation executing unit as an instruction executing unit. Composed of Te.

[0008]

DESCRIPTION OF THE PREFERRED EMBODIMENTS Next, the present invention will be described with reference to the drawings.

FIG. 1 is a system configuration diagram showing a first embodiment of the present invention. As shown in FIG. 1, in this embodiment,
A simulator / program executing means 101 including an input unit 103, an analyzing unit 105, a control / display unit 106, and a simulation executing unit 107, an input file 102, and a console 104 are provided.

Simulator program executing means 101
As described above, the input unit 103 for inputting the file information of the input file 102, the analysis unit 105 for analyzing the character string in the activation line input from the console 104, and the simulation result by the analysis unit 105 The execution unit 107 is formed by a control / display unit 106 for controlling the execution unit 107 and a simulation execution unit 107 for simulating an instruction for file information input via the input unit 103. 107 includes an instruction execution unit 108 that executes instructions, and a memory / register content holding unit 112 that holds the contents of memory and registers. Further, the instruction execution unit 108 further includes
A stack information detection unit 109 that detects memory information used by the stack, a stack designated value holding unit 110, and a stack value holding unit 111 are included.

FIG. 2 is a flow chart showing the processing procedure in the stack information detecting section 109 included in the simulator / program executing means 109 in this embodiment. The file information input from the input file 102 to the simulator / program executing means 109 is processed in the following procedure when a startup line instructing execution of the program is input to the console 104.

In this embodiment, the value of the stack pointer is assigned from the memory area having a large address value. Moreover, "beginning" and "end" in the flowchart of FIG. 2 correspond to the command input waiting state of the simulation.

First, in the initialization processing step 201, the initial value of the stack pointer is set in the variable SP MIN. In the initialization processing step 202, the stack size obtained from the file information input from the input file 102 is subtracted from the value of SP MIN set in the initialization processing step 201, and the value is set in the variable SP SIZE. To do. Read processing step 2
In 03, one command is read from the input file information. In the end determination processing step 204,
The instruction read in the read processing step 203 is
It is determined whether or not the instruction is an instruction to be executed in the console 104 of FIG. This end determination processing step 2
In 04, if it is the instruction instructed to be executed by the console 104, the process proceeds to the instruction execution processing step 206, and if it is not the instruction instructed to be executed by the console 104, the console 1 is executed.
It is determined that the execution of the program by 04 has ended, and the minimum stack pointer value output processing step 205
Move to.

In the minimum stack pointer value output processing step 205, the value of SP MIN is set to the console 1
It outputs to 04 and sets the simulator to the state of waiting for command input. The SP MIN displayed here is
It represents the minimum address value of the memory area used by the stack during program execution.

On the other hand, in the instruction execution processing step 206, the instruction read in the reading processing step 203 is executed, and the result is stored in the memory and the register. The processing in this instruction execution processing step 206 is
It is executed by the instruction execution unit 108 and the memory / register content holding unit 110 of FIG.

In the command decision processing step 207,
The instruction read in the read processing step 203 is
It is determined whether the instruction is a stack operation instruction. If,
The instruction read in the read processing step 203 is
If it is an instruction to operate the stack, the process proceeds to the stack pointer error determination processing step 208. If not, it is determined that the read instruction is not an instruction to operate the stack, and the read processing step 203. Return to.

In the stack pointer error judgment processing step 208, the value of the stack pointer is the SP SI set in the initialization processing step 202.
It is determined whether it is smaller than ZE. If the stack pointer value is smaller than SP SIZE, it is determined that the stack pointer value exists within the set stack area, and the minimum stack
The process proceeds to pointer determination processing step 211. If not, it is determined that the value of the stack pointer exists outside the set stack area,
The process proceeds to error message output processing step 209. In the error message output processing step 209, a message indicating that the stack has overflowed is output to the console 104 of FIG. In the simulator stop processing step 210, upon receiving the message, the simulator is set to the command input waiting state and the processing ends.

On the other hand, in the minimum stack pointer determination processing step 211, the value of the stack pointer is S.
It is determined whether or not it is smaller than P MIN, and if the value of the stack pointer is smaller than SP MIN, the value of the current stack pointer becomes the value of the smallest stack pointer at the present time. Is determined, the process proceeds to the minimum stack pointer storage processing step 212. Otherwise, it is determined that it is not necessary to save the current stack pointer value, and the process returns to the read processing step 203. If the value of the stack pointer is smaller than SP MIN, the minimum stack pointer save processing step 212
In, the current stack pointer value is assigned to SP MIN, and the flow returns to the read processing step 203.

As described above, when the program execution is instructed from the console 104, the SP MI
N is detected and output to the console 104. The value of SP MIN detected here represents the minimum stack pointer value of the memory area used by the stack when the program is executed. Furthermore, when trying to use a stack area other than the stack area where the stack is set during program execution, the error / message output processing step 209 and the simulator stop processing are determined by the determination by the stack pointer error determination processing step 208. Go to step 210, output a stack overflow error message to the console 104,
Set the simulator to the command input waiting state.

Next, a second embodiment of the present invention will be described. The system configuration of this embodiment is the same as that of the first embodiment shown in FIG. The difference between this embodiment and the first embodiment is that in the first embodiment, the input file 1
In contrast to executing the instruction after reading the instruction from 02, in the present embodiment, the instruction is executed after determining whether or not the read instruction is a stack operation instruction. is there.

FIG. 3 shows a simulator according to the present embodiment.
9 is a flowchart showing a processing procedure in a stack information detection unit 109 included in the program execution means 109. The file information input from the input file 102 to the simulator / program executing means 109 is processed in the following procedure when a startup line instructing execution of the program is input to the console 104.

In the present embodiment, the stack pointer value is assigned from a memory area having a large address value, as in the case of the first embodiment. Further, “beginning” and “end” in the flowchart of FIG. 3 correspond to the command input waiting state of the simulation.

The processing procedure from processing step 301 to processing step 305 in the flow chart of this embodiment is the same as the processing procedure from processing step 201 to processing step 205 in the first embodiment. Further, the processing procedure from processing step 309 to processing step 311 in the present embodiment is performed in the same manner as the processing procedure from processing step 208 to processing step 210 in the first embodiment. Therefore, the description of these processing procedures will be omitted.

Instruction determination processing steps 306 and 307
In step 1, it is determined whether the instructions read in the read processing step 303 are CALL instructions and PUSH instructions, respectively. If it is determined to be a CALL instruction in the instruction determination processing step 306, the PUS is determined in the instruction determination processing step 307.
If determined to be H instructions, these instructions
Since both are instructions for operating the stack, the processing procedure is the stack pointer error determination processing step 30.
Move to 9. In addition, in these instruction determination processing,
If they are neither the CALL instruction nor the PUSH instruction, the process proceeds to the instruction determination processing step 308.

In the command decision processing step 308,
As with instruction processing steps 306 and 307,
The command read in the read processing step 303 is
It is determined whether it is a POP instruction. If it is determined that it is a POP instruction, it is an instruction to operate the stack, so the stack pointer error determination processing 30
Move to 9. If not, the process proceeds to the instruction execution processing step 314. Instruction execution processing step 3
In 14, the same processing as the instruction execution processing step 206 in the case of the first embodiment is performed, and after the processing is completed, the processing returns to the reading processing step 303 to read the next one instruction.

On the other hand, in the stack pointer error determination processing step 309 and the minimum stack pointer determination processing 312, the same processing as the processing steps 208 and 211 in the above-mentioned first embodiment is performed, but the minimum stack In the pointer determination processing 312,
If it is determined that the value of the stack pointer is smaller than the value of SP MIN, the processing moves to the minimum stack pointer saving processing step 313, and if not, the processing moves to the instruction execution processing step 314. The processing content in the minimum stack pointer storage processing step 313 is the same as the processing step 212 in the first embodiment, and after the processing is completed, the processing moves to the instruction execution processing step 314. In the instruction execution processing step 314, the instruction is executed to save the contents of the memory / register, and after the processing is completed, the processing returns to the processing step 303 to read one instruction.

[0027]

As described above, the present invention detects the address value of the memory area when the stack is used most at the time of executing the program and outputs it, thereby making it possible to determine the stack size at the time of executing the program. It is possible to confirm with, and it is possible to eliminate the trouble and time required to confirm the stack size, and
There is an effect that the stack size can be set accurately.

[Brief description of drawings]

FIG. 1 is a system configuration diagram showing an embodiment of the present invention.

FIG. 2 is a diagram showing a flowchart of a processing procedure in the first embodiment of the present invention.

FIG. 3 is a diagram showing a flowchart of a processing procedure in the second embodiment of the present invention.

[Explanation of symbols]

 101 Simulator / Program Execution Means 102 Input Console 103 Input Unit 104 Console 105 Analysis Unit 106 Control / Display Unit 107 Simulation Execution Unit 108 Instruction Execution Unit 109 Stack Information Detection Unit 110 Stack Specified Value Holding Unit 111 Stack Value Holding Unit 112 Memory / Register content holding unit 201 to 212, 301 to 314 Processing step

Claims (1)

[Claims] 1. A file information input unit for inputting information created by a language processing program from a predetermined file, a simulation execution unit for simulating an instruction corresponding to the input of the information, and a predetermined monitor control unit. An analysis unit that analyzes the content of the character string on the startup line input from the console, receives the character string analysis result by the analysis unit, controls the execution of the program in the simulation execution unit, and executes the simulation execution state. In a simulator execution method formed by at least a control / display unit that displays information including, a program execution in the simulation execution unit,
A stack information detection unit that detects and outputs the memory area information used by the stack, a stack designated value holding unit that holds the designated value of the stack pointer, and a stack value holding unit that holds the stack pointer value during instruction execution. And a simulator execution method comprising: