JPH05241902A - Software simulator - Google Patents

Abstract

PURPOSE:To provide the history of execution to a point, where the amount of used stack exceeds the amount designated by a user, to a program developer in the case of deciding the size of a stack area to be dynamically changed while executing a program. CONSTITUTION:In respect to the conventional software simulator, a stack state display designating amount input processing step 200 is provided just after execution start, and the amount designated by the user is inputted for starting the display of a stack state from an activated line. A stack state display processing step 300 is provided behind a single instruction execution processing step 104 and the point, where the amount of used stacks exceeds the amount designated by the user, is judged. The function names of all the functions executed until the point, where the amount of used stacks exceeds the amount designated by the user, and the amount of used stacks for each function are displayed according to the calling order of functions. Therefore, the size of the stack area can be easily decided.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a software simulator, and more particularly, to displaying a stack usage status during instruction execution of a microprocessor to be simulated.

[0002]

2. Description of the Related Art FIG. 6 shows an overall processing flow of processing for instructing an operation in command units from an input device in a conventional microprocessor software simulator. In the command input processing step 100, a command is input from the input device, and in the command analysis processing step 101, the command is analyzed and branched to each command processing step 102. In the command processing step 102, display of memory contents, display of register contents, execution of steps, execution of runs and the like are performed.

Instruction execution system command determination processing step 10
At 3, it is determined whether the command is an instruction execution type command such as step execution or run execution. If the result of determination is that the command is an instruction execution type command, single instruction execution processing step 10
The instruction is executed in step 4, and after the execution, the break condition is satisfied, the instruction is abnormal at the time of execution, or an external forced stop instruction is generated in the instruction execution end determination processing step 105.
Depending on the result, the next instruction is continued, or the process branches to the command input processing step 100, and the repeating processing is continued thereafter.

Next, a method of grasping the stack state during instruction execution and determining an appropriate stack area using the software simulator described above will be described. If the preset stack area is insufficient, an access break condition is set for the area beyond the stack area and a series of instructions are executed. When the break condition is satisfied and the instruction execution is stopped, the execution history of the function and the stack usage amount of each function are obtained from the state saved in the stack, and the program algorithm is changed or the function parameter is changed. Reduce the stack usage by changing the above. When the stack usage cannot be reduced, the stack area is expanded. When there are a plurality of places where the break condition is satisfied, the above work is performed a plurality of times to determine the optimum stack area.

[0005]

The problem to be solved is to detect a program location where the stack usage exceeds the stack area with respect to the stack usage dynamically changing during execution of a series of instructions. The point is that the operation is complicated. Therefore, there has been a problem that the operation until detecting a program portion whose stack usage amount exceeds the stack area is complicated.

[0006]

Means for Solving the Problems The software of the present invention
The simulator determines the points where the stack usage exceeds the user specified quantity during program execution of the microprocessor to be simulated, and the functions of all functions executed up to the point where the stack usage exceeds the user specified quantity. It is characterized in that the name and the stack usage amount for each function are displayed in accordance with the function calling order.

[0007]

DESCRIPTION OF THE PREFERRED EMBODIMENTS Next, the present invention will be described with reference to the drawings. FIG. 1 is an overall processing flow showing an embodiment of a software simulator according to the present invention. In FIG. 1, 100 is a command input processing step, 101 is a command analysis processing step, 102 is a command processing step, 103 is an instruction execution type command determination processing step, 1
Reference numeral 04 is a single instruction execution processing step, 105 is an instruction execution end determination processing step, 200 is a stack state display designated amount input processing step, and 300 is a stack state display processing step.

In addition to the conventional process flow, immediately after the start, the stack state display designated amount input processing step 200 for inputting the user designated amount is arranged in order to start displaying the stack state from the startup line. Further, after the single instruction execution processing step 104, a point where the stack usage exceeds the user specified quantity is determined, and the function names of all the functions executed up to the point where the stack usage exceeds the user specified quantity and each function. Stack display amount is displayed in accordance with the function calling order, the stack state display processing step 30
0 is added.

Further, in the present invention, as shown in the figure, a stack use amount storage data array (hereinafter referred to as a function table) for each function at the time of executing an instruction is added. The data structure of the function table is a function name during instruction execution, a stack pointer at the start of function execution (hereinafter referred to as the top SP), and a maximum stack pointer during function execution (hereinafter referred to as the current SP). Is constituted by a series of data elements and a pointer indicating the head of the group (hereinafter referred to as a function pointer).

FIG. 3 is a processing flow showing the details of the stack state display processing step shown in FIG. next,
The processing flow in the stack status display processing step 300 will be described with reference to FIG. In this embodiment, it is assumed that the stack area is a microprocessor secured in the direction from the high address to the low address of the memory. First, in the initial state determination processing step 301, it is determined whether or not this processing has been executed in an initial state in which instruction simulation has never been executed by the software simulator.
When this processing is executed in the initial state, the function name at the present time, the start S
Set P, current SP, and function pointer to function table. Further, in the display flag setting processing step 303, the display flag is initialized to off.

Next, a change in the stack pointer after the execution of the previous instruction is judged in the stack pointer increase / decrease judgment processing step 304. If there is no increase / decrease, the process ends as it is. If the stack pointer increases due to processing such as saving arguments, return addresses, or temporary variables in a function to the stack area when calling another function, the maximum stack pointer determination processing step At 305, the current stack pointer is compared with the current SP of the data structure indicated by the function instruction pointer. If the stack pointer is larger than the current SP, in the function table update processing step 306,
Store the stack pointer in the current SP area. Further, in the function name acquisition processing step 307, the name of the function currently being executed is obtained from the program counter after executing the instruction and the function symbol table generated in advance by the language processing program.

Next, execution function change determination processing step 30
In step 8, it is determined whether or not the execution function name before executing the instruction is different from the function name obtained in the function name acquisition processing step 307. If they are different, display flag setting processing step 3
At 09, the display flag is set to off. Furthermore, at the function table addition processing step 310, at the end of the function table,
The function name at the present time, the first SP, and the current SP are added, and the function instruction pointer is updated.

On the other hand, in the stack pointer increase / decrease determination processing step 304, when the stack pointer decreases due to recovery from the stack area or the like, the function name acquisition processing step 307 is executed, and the execution function change determination processing step 308. Then, it is determined whether or not the execution function name before the instruction is executed and the function name obtained in the function name acquisition processing step 307 are different. If they are the same, the processing is terminated as it is.
If they are different, the stack usage amount calculation processing step 311 is executed first to the current S of the data structure indicated by the function instruction pointer from the first SP of the data structure of the first function.
P is subtracted to calculate the current stack usage.
Next, the stack usage amount determination processing step 312 compares the user-specified amount with the obtained stack usage amount. If the stack usage amount exceeds the user specified amount, display flag determination processing step 313 is executed.

If the display flag is off, the function name and stack usage display step 314 displays the function name up to the present time and the stack usage for each function.
The display is performed according to the function calling order, and the display flag is turned on in the display flag setting processing step 315. Next, in the function table deletion processing step 316, the function name storage area of the data structure indicated by the function instruction pointer is filled with the numerical value 0, and the instruction of the function instruction pointer is returned by one. As a result, the function name before the instruction execution from the function table, the head S
P and the current SP are deleted, and the process ends. If the stack usage amount does not exceed the user-specified amount in the stack usage amount determination processing step 312, or if the display flag is on in the display flag determination processing step 313, the function table deletion processing step 316 is executed. Then, the process ends.

Next, a display example in the case where the stack usage amount exceeds the user designated amount in the present embodiment will be described. As an example, the description will be given using C language, which is one of the high-level languages. First, a method of using a stack in general C language will be described with reference to FIG. In FIG.
(a) shows the first source program, and FIG. 4 (b) shows the use status of the stack.

The first source program 400 shown in FIG. 4 (a) has an external function declaration section 401 that declares that the function FUNC2 is an external function, a function declaration section 402 that indicates the beginning of the function func1, and a function. A variable declaration unit 403 that declares temporary variables i, j, l in func1, a variable assignment unit 404 that assigns a numerical value to the temporary variables i, l, i,
Call the function FUNC2 with l as an argument, and
It is composed of a function calling unit 405 which substitutes the return value of C2 into the temporary variable j. The stack usage status at this time is shown in Fig. 4 (b).

Since the stack area is assumed to be a microprocessor secured in the direction from the high address to the low address of the memory, temporary variables i, j and l are stored in the variable declaration section 403 of FIG. 4 (a). Stacked in area 406. At this point, it is the stack pointer 409. Next, in the function calling unit 405 of FIG. 4A, the argument 1 and the argument i are stacked in the argument storage area 407, and further, the function fu
The return address to nc1 is the return address storage area 408 to the function.
Piled up. At this point, the stack pointer becomes the second stack pointer 410. External function FUNC2
After executing, the stack pointer is returned to the first stack pointer 409 in order to release the return address storage area 408 and the argument storage area 407 for the function which is no longer needed in the function funcl.

FIG. 5 is an explanatory diagram showing the structure of the second source program, the state of the stack area, and the state of the function table. The process from the start of execution of the second source program to the step of outputting a display example when the amount of stack usage exceeds the amount specified by the user, based on the general method of using the stack in C described above, is shown in FIG. ~ Figure 3
Will be described. Here, FIG. 5 is an explanatory diagram showing the second source program 500. Further, FIG. 13 is a display example when the stack usage amount exceeds the user-specified amount.

The second source program 500 shown in FIG.
In, the main function is defined by the main function declaration unit 501 to the main function termination unit 505. The main function is the variable declaration part 5 of the temporary variables i and j.
02, the func1 function calling unit 503, and func
2 function call unit 504.

The func1 function is defined by the func1 function declaring unit 506 to the func1 function terminating unit 508, and includes a variable declaring unit 507 of the temporary variable x. The func2 function is defined by the func2 function declaration unit 509 to the end unit 512 of the func2 function, and the variable declaration unit 510 of the temporary variables i and j and the fun
and a c3 function calling unit 511. The func3 function is defined by the func3 function declaration unit 513 to the end unit 516 of the func3 function, and the temporary variable x
Variable declaration part 514 and func4 function calling part 51
It consists of 5 and. The func4 function is defined by the func4 function declaration unit 517 to the func4 function termination unit 519, and includes the variable declaration unit 518 of the temporary variable x.

The user designated amount obtained in the stack state display designated amount input processing step 200 of FIG. 1 is set to 15 bytes, and the stack pointer when the main function is executed is 7ffeH, 7ffeH and 7fffH of the stack area. It is assumed that each stores the return address of the main function. Where C language in
The size of the t type is 2 bytes, and the maximum length of the function name that can be described is 8 characters. Therefore, the function name storage area of the function table is fixed to secure 8 bytes, and in the case of a function name of less than 8 characters, the remaining area is filled with the numerical value 0.

First, in the main function declaring section 501 of FIG. 5, normally, only the function name of the main function exists, and there is no execution instruction for executing the simulation by the software simulator. At the time when the variable declaration unit 502 declares the temporary variables i and j, in the initial state determination processing step 301 of FIG. 2, the simulation of the instruction has not been executed even once. Therefore, in the function table creation processing step 302, the current function table shown in FIG. 6B is created. Further, in the display flag setting processing step 303, the display flag is initialized to off.

In the stack pointer increase / decrease determination processing step 304, the stack pointer before execution and the stack pointer after execution are compared. Here, the temporary variables i and j are stacked on the stack and the stack pointer is increased. Therefore, even in the maximum stack pointer determination processing step 305, the current SP of the data structure indicated by the function instruction pointer becomes larger than the current stack pointer. Therefore, the function table update processing step 306 stores the stack pointer in the current SP area. Further, in the function name acquisition processing step 307, main is obtained as the function name. next,
The execution function change determination processing step 308 is executed, but the execution function name before the instruction execution and the function name acquisition processing step 307
Since both the function name obtained in step 1 and main are main, the process is terminated. In the variable declaration unit 502 of FIG. 5, the state of the stack is as shown in FIG. 6 (a), and the function table is as shown in FIG. 6 (b).

In the func1 function calling unit 503, the arguments i and j to the function func1 and the return address of the function func1 are stacked on the stack. Since the stack has increased, the maximum stack pointer determination processing step 305
However, the current SP of the data structure indicated by the function instruction pointer becomes larger than the current stack pointer. Therefore, the function table update processing step 306
Then, the stack pointer is stored in the current SP. Further, in the function name acquisition processing step 307, func1 is obtained as the function name.

Next, the execution function change judgment processing step 30
8, the execution function name main before executing the instruction is different from the current function name obtained in the function name acquisition processing step 307. Therefore, in the display flag setting processing step 309,
Set the display flag to off. Further, in the function table addition processing step 310, the function table addition processing at the present time is performed at the end of the function table, and the processing ends. In the func1 function calling unit 503 of FIG.
The state of the stack is as shown in FIG. 7 (a), and the function table is as shown in FIG. 7 (b).

The processes of the func1 function declaration unit 506 and the variable declaration unit 507 are the same as the processes described above.
In the variable declaration unit 507 in the function func1 of FIG.
The state of the stack is as shown in FIG. 8 (a), and the function table is as shown in FIG. 8 (b). At the end portion 508 of the func1 function, the temporary variable x is deleted from the stack area, execution returns to the main function, and further, func1
The return address of the function and the arguments i and j are deleted from the stack. Since the stack pointer has decreased, the function name acquisition processing step 307 is executed, and the function name main
To get.

Next, execution function change determination processing step 30
8, the execution function name func1 before the instruction execution is different from the current function name obtained in the function name acquisition processing step 307. Further, the first SP of the data structure of the first function is 7
ffeH, the current SP of the data structure indicated by the function instruction pointer is 7ffe4H. Therefore, the stack usage amount calculation processing step 311 is executed to determine that the stack usage amount is 10 bytes. Further, in the stack usage amount determination processing step 312, the obtained stack usage amount of 10 bytes is compared with the user specified amount of 15 bytes, and it is confirmed that the stack usage amount does not exceed the user specified amount. Therefore, in the function deletion processing step 316, the information of the function func1 is deleted from the function table, and the processing ends. In the terminal part 508 of the func1 function in FIG. 5, the state of the stack is as shown in FIG. 6 (a) and the function table in FIG. 6 (b).

Func2 function calling unit 504, fun
c2 function declaration part 509, variable declaration part 510, func3
Function calling unit 511, func3 function declaration unit 513,
Variable declaration unit 514, func4 function calling unit 515,
The processes of the func4 function declaration unit 517 and the variable declaration unit 518 are the same as the processes described above. In the variable declaration unit 518 of FIG. 5, the state of the stack is as shown in FIG. 9 (a), and the function table is as shown in FIG. 9 (b).

At the end portion 519 of the func4 function, the temporary variable x is deleted from the stack area, execution is returned to the func3 function, and the return address of the func4 function and the argument i are deleted from the stack. Since the stack pointer has decreased, the function name acquisition processing step 307 is executed,
Func3 is acquired as the function name. Next, in the execution function change determination processing step 308, the execution function name func4 before the instruction execution is different from the current function name obtained in the function name acquisition processing step 307. Further, the head SP of the data structure of the head function is 7ffeH, and the current SP of the data structure indicated by the function instruction pointer is 7ffe6H. Therefore, the stack usage calculation step 311 is executed to determine that the stack usage is 24 bytes. Further, in the stack usage amount determination processing step 312, the obtained stack usage amount of 24 bytes is compared with the user specified amount of 15 bytes, and it is confirmed that the stack usage amount exceeds the user specified amount. Therefore, the display flag determination processing step 313 is executed.

Here, since the display flag is off, in step 314 of displaying the function name and stack usage amount, the function name up to the present time and the stack usage amount for each function are displayed according to the function calling order and the display flag is set. In process step 315, the display flag is turned on. Furthermore, in the function deletion processing step 316, the function fun is deleted from the function table.
The information of c4 is deleted, and the process ends. 5 func
In the terminal portion 519 of the 4-function, the stack state is shown in FIG.
0 (a), and the function table is shown in Fig. 10 (b).
As shown in. The display example of the function name and the stack usage amount is as shown in FIG.

In the end part 515 of the func3 function, fu
The same processing as the termination unit 519 of the nc4 function is executed,
The processing after the display flag determination processing step 313 is different. In the display flag determination processing step 313, since the display flag is on, the function deletion processing step 316
Then, the information of the function func3 is deleted from the function table, and the process ends. In the terminal part 515 of the func3 function of FIG. 5, the state of the stack is as shown in FIG. 11 (a), and the function table is as shown in FIG. 11 (b). In the terminal part 512 of the func2 function of FIG. 5, the stack state is as shown in FIG. 6 (a), and the function table is as shown in FIG. 6 (b). In the main function termination unit 505 of FIG. 5, the stack state is as shown in FIG. 12 (a), and the function table is as shown in FIG. 12 (b).

[0032]

As described above, according to the present invention, when the program developer decides the stack area, the function name and the stack usage amount are displayed according to the calling order of the function when the program is executed, so that the optimum stack size can be obtained. This has the effect of reducing the detection man-hours and the man-hours for changing the stack usage method for obtaining

[Brief description of drawings]

FIG. 1 is a flow of overall processing showing an embodiment of a software simulator according to the present invention.

FIG. 2 is a flow chart of a stack status display process.

FIG. 3 is a configuration diagram of a function table.

FIG. 4 is a first source program structure and a first
FIG. 6 is an explanatory diagram showing the usage status of the stack area of the source program of FIG.

FIG. 5 is an explanatory diagram showing a configuration of a second source program, a state of a stack area, and a state of a function table.

FIG. 6 is an overall processing flow showing a software simulator according to a conventional technique.

[Explanation of symbols]

100 to 105, 200, 300, 301 to 316 Processing step 400, 500 Source program 401 to 405, 501 to 519 Source program component 406 to 410 Stack area component

─────────────────────────────────────────────────── ───

[Procedure amendment]

[Submission date] December 22, 1992

[Procedure Amendment 1]

[Document name to be amended] Statement

[Name of item to be corrected] Brief description of the drawing

[Correction method] Added

[Correction content]

[Brief description of drawings]

FIG. 1 is a flow of overall processing showing an embodiment of a software simulator according to the present invention.

FIG. 2 is a flow chart of a stack status display process.

FIG. 3 is a configuration diagram of a function table.

FIG. 4 is a first source program structure and a first
FIG. 6 is an explanatory diagram showing the usage status of the stack area of the source program of FIG.

FIG. 5 is an explanatory diagram showing a configuration of a second source program, a state of a stack area, and a state of a function table.

FIG. 6 is an overall processing flow showing a software simulator according to a conventional technique.

FIG. 7 is a diagram showing a stack state of a calling unit of a func1 function.

FIG. 8 is a diagram showing a stack state of a variable declaration unit in func1 and a function table.

FIG. 9 is a diagram showing a stack state of a variable declaration part and a function table.

FIG. 10 shows the state of the stack at the end of the func4 function,
It is a figure which shows and a function table.

FIG. 11 shows the state of the stack at the end of the func3 function,
It is a figure which shows and a function table.

FIG. 12 is a diagram showing a stack state at the end of the main function and a function table.

FIG. 13 is a diagram showing a display example of a function name and a stack usage amount.

FIG. 14 is a diagram showing an overall processing flow of processing for instructing an operation in command units from an input device of a software simulator for a microprocessor.

[Description of Reference Signs] 100 to 105, 200, 300, 301 to 316 Processing Steps 400 and 500 Source Program 401 to 405, 501 to 519 Source Program Components 406 to 410 Stack Area Components

Claims (3)

[Claims] 1. In a simulation of a microprocessor having a stack mechanism for the purpose of saving and recovering processing data, a point where the stack usage exceeds a user specified quantity is determined when a program of the microprocessor to be simulated is executed. Display means for displaying the function names of all the functions executed up to the point where the stack usage exceeds the user specified quantity and the stack usage for each function in accordance with the function calling order. A software simulator with and. 2. The display means determines generation of a function table, and if not generated, generates a function table, and then determines increase / decrease of stack pointer; and when the stack pointer increases, stack pointer Is larger than the current SP, and when the former is larger than the latter, the function table is updated,
By determining the execution function change by acquiring the function name,
When changing, the display flag is turned off and a function table is added, and when the stack pointer decreases, the function name is acquired to determine the execution function change, and when changing, the stack usage amount is calculated, and then the user specifies 2. The step of determining whether the amount is larger than the stack usage amount, displaying the function name and the stack usage amount when the former is larger than the latter, and turning on the display flag to delete the function table. Software simulator. 3. The function table includes a function name, a head SP,
The software simulator according to claim 1, wherein the software simulator is configured to include a current SP and a current SP.