JP2002157128A - Method for allocating stack area to compiler and compiler - Google Patents

Abstract

PROBLEM TO BE SOLVED: To dispense with securing useless stack area by dispensing with securing any memory area in a stack for members of a structure not referred to when allocating stack area during compilation. SOLUTION: During compilation, when the area of a local variable of the structure is allocated to the stack, a program is scanned to check if there is a portion referring to the relevant member of the structure. Only when the member of the structure is referred to and a memory area for the structure member is not yet secured, the memory area for the structure member is secured on the stack area.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

The present invention relates to a method for allocating a stack area of a compiler and, more particularly, to a method and a compiler for allocating a stack area of a local variable memory area to a stack area.

[0002]

2. Description of the Related Art When a function is called, a compiler such as the C language secures a memory area for storing its variables,
The variable (local variable) is allocated to the stack area as needed. As a prior art relating to the compiler of this tree, for example, "Compiler II by Eiho, Cessie and Ullman" (Science Inc., 1990), p.
The technique described on page 96 is known. In this conventional technique, the size of the stack area required for each function,
At the time of compilation, allocation of a stack area such as which position of the area is to be associated with which local variable is performed.

[0003] In the above-mentioned prior art, when a local variable is a structure, the structure is regarded as one variable as a whole. Therefore, even when there is only a reference to one member of the structure, the entire structure is not included. The memory area was secured on the stack area.

[0004]

The prior art described above is
When a structure with multiple members is a local variable, even if there is a member not referenced in the program, the structure is allocated to the entire structure on the stack. However, there is a problem that a stack area is wastefully secured.

SUMMARY OF THE INVENTION An object of the present invention is to solve the above-mentioned problems of the prior art, and to provide a compiler which does not need to secure a useless stack area without securing a memory area on the stack for members of a structure not referred to. An object of the present invention is to provide a stack area allocating method and a compiler.

[0006]

According to the present invention, there is provided a method for allocating a stack area of a compiler, comprising:
When allocating a memory area for a local variable of a structure on the stack area, it checks whether each of the multiple members included in the structure is a referenced member, and checks the member of the referenced structure This is achieved by allocating a stack area for the non-referenced structure and not reserving the stack area for members of the structure that are not referred to.

According to the present invention, when allocating an area of a local variable of a structure to a stack, the program is scanned to check whether or not there is a location referring to a member of the relevant structure. If there is, only the memory area of the referenced member is secured on the stack area. As a result, a memory area is not secured in the stack for members of a structure that is not referred to, so that it is not necessary to secure a useless stack area.

[0008]

BRIEF DESCRIPTION OF THE DRAWINGS FIG. 1 is a block diagram showing an embodiment of a method for allocating a stack area of a compiler according to the present invention;

FIG. 1 is a block diagram showing the configuration of a computer system on which a compiler according to an embodiment of the present invention operates.
FIG. 2 is a flowchart for explaining the processing operation of the compilation, FIG. 3 is a flowchart for explaining the processing operation of the structure reference analysis processing, FIG. 4 is a flowchart for explaining the processing operation of the stack allocation processing, and FIG. FIG. 6 is a diagram illustrating an example of a program, FIG. 6 is a diagram illustrating a partial example of a symbol table generated from the source program of FIG. 5, and FIG. 7 is an example in which a memory on a stack area is allocated to a structure by a conventional technique. FIG. 8 is a diagram showing an example in which a memory on a stack area is allocated to a structure according to the embodiment of the present invention. In FIG. 1, 101 is a CP.
U, 102 is a display device, 103 is a keyboard,
104 is a main storage device, 105 is a compiler, 106 is an intermediate code, 107 is an external storage device, 108 is a source program, and 108 is an object program.

A computer system on which a compiler according to an embodiment of the present invention operates has, as shown in FIG.
1, a display device 102, a keyboard 103, a main storage device 104, and an external storage device 107. The main storage device 104 holds a compiler 105 and an intermediate code 106 required in the compiling process. The external storage device 107 holds a source program 108 and an object program 109. The compiling process is performed by the CPU 101 using the compiler 1
04 is performed. The user gives a command to the compiler 104 from the keyboard 103,
The display device 102 informs the user of the end of compilation or an error.

Next, the compile processing operation will be described with reference to the flow shown in FIG.

(1) First, the source program 108 is read, and the intermediate code 10 that can be processed inside the compiler is read.
6 and a syntax analysis process for generating a symbol table described later with reference to FIG. The details of the parsing process are described in, for example, "Compiler II by Eiho, Seshi and Ullman" (Science Inc., 1990), pp. 30-74.
The generation of the symbol table is also described on pages 521 to 535 of the same book, and the description is omitted here (step 201).

(2) Next, a structure reference analysis process is executed. Details of the structure reference analysis processing will be described later with reference to the flow shown in FIG.
2).

(3) Next, a stack allocation process is performed. This stack allocation processing is described in FIG.
The details will be described later with reference to the flow shown in FIG.

(4) Next, an object code generation process is executed to generate an object code, and the process ends. For more information on this object creation process, see "
Cessy, Ullman: Compiler II "(Science,
(1990), pages 624 to 707, and a description thereof will be omitted (step 204).

Before describing the details of the structure reference analysis process and the stack allocation process, an example of a source program used in the embodiment of the present invention will be described with reference to FIG. An example of a part of a symbol table generated from the source program shown in FIG. 5 will be described with reference to FIG.

The example of the source program shown in FIG.
A structure defined by a structure shown as 1 to 505 is declared in 508 as a local variable a used in the function func (). That is, 501 to 505 declaring a structure declare that the type foo is a structure having x, y, and z as members. And 506- which is the part that defines the function
At 514, the variable of the function shown as 506 is 50
8, 509, the local variable a and the structure member x,
A sentence indicating processing of a program using y and z is 510
514. The members of the structure referenced by the program from the statement indicating the processing of this program are:
It can be seen that there are only members x and y among all the members x, y and z constituting the structure.

A symbol table generated from such a source program is, for example, as shown in FIG. In FIG. 6, the symbol table 601 corresponds to 501 to 50 shown in FIG.
5, corresponding to the structure a declared in FIG.
3, 604 are members x, y, z of the structure a
Is a symbol table. The symbol table has a list structure having a hierarchical structure. The symbol table 601 is included in a list of symbols declared in the function, and a symbol table 602 is provided below the symbol table as a symbol table list of structure members. To 604 are added in a list structure. Each symbol table contains the name of the symbol,
Holds information on the type, size, arrangement position, and flag indicating presence / absence of memory reference. The position information is undecided as an initial value, and the memory reference information is FALSE as an initial value.

FIG. 7 shows a stack area in which the above-mentioned structure a is allocated to the memory area by the conventional method. That is, in the case of the related art, x, which is a member of the structure a, is placed on the stack area 701.
Areas y and z are areas 702, 703, and 704, respectively.
Will be assigned as

Next, with reference to the flow shown in FIG. 3, the processing operation of the structure reference analysis processing which is one of the characteristic processing of the present invention will be described. This process checks if it is necessary to take memory space for the members of the structure,
This is a process of setting a flag on a member.

(1) First, it is checked whether or not there is a sentence that has not yet been processed. If all the sentences have been processed, the structure reference analysis processing ends as it is. If there is an unprocessed sentence, the next sentence is extracted (steps 301 and 302).

(2) Next, it is checked whether or not the statement extracted in step 302 is a memory reference statement of a local variable. If the statement is not a memory reference statement of a local variable, step 301
The process returns to (Step 303).

(3) In step 303, if the statement is a memory reference statement of a local variable, it is checked whether or not the statement is a reference to a structure. Return to the processing from step 301 (step 30)
4).

(4) In step 304, if the statement is a reference to a structure, it is checked whether or not the reference to the structure is a reference to a member of the structure. If it is, it is checked whether the memory reference flag of the symbol table corresponding to the member of the structure already referred to is set to TRUE. If the flag has been set to TRUE, the process returns to step 301 (step 30).
5, 306).

(5) If the memory reference flag is not set to TRUE in step 306, the memory reference flag of the symbol table corresponding to the member of the structure being referred to is set to TRUE, and then the processing from step 301 is performed. (Step 307).

(6) In step 305, if the reference to the structure is not a reference to a member of the structure, it is a reference to the entire structure, so that the memory of the symbol table corresponding to the whole of the corresponding structure is stored. It is determined whether or not the reference flag is set to TRUE. If the flag is set to TRUE, the process returns to step 301 (step 308).

(7) In step 308, the flag is set to TRU
If it is not E, the memory reference flag of the symbol table corresponding to the entire structure being referred to is set to TRUE, and the process returns to Step 301 (Step 30).
9).

Next, the processing operation of the stack allocation processing which is one of the characteristic processing of the present invention will be described with reference to the flow shown in FIG. In this processing, a stack area is not reserved for members of a structure that is not referred to, and a memory area corresponding to a variable is allocated on the stack area.

(1) First, preparations are made to process the symbol table list of the entire function, and it is checked whether there is a symbol table that has not been processed yet. As a result, if there is an unprocessed symbol table, the unprocessed symbol table is extracted (step 401).
403).

(2) Next, it is checked whether or not the unprocessed symbol table extracted in step 403 is a symbol table of a structure.
If it is a symbol table of a structure, it is checked whether or not the memory reference flag of the symbol table is TRUE (step 404,
405).

(3) If the memory reference flag of the symbol table is TRUE in step 405, a memory area having the size of the entire structure is taken on the stack area, and the process returns to step 402 to return to the processing from the symbol table. If the memory reference flag is not FALSE but TRUE, the symbol table list of members of the structure of the symbol table is processed recursively to prepare for processing of the symbol table list of the structure member being processed. After that, the process returns to step 402 (steps 406 and 409).

(4) If the symbol table is not the symbol table of the structure in step 404, it is checked whether or not the memory reference flag of the symbol table is TRUE.
If it is FALSE instead of the UE, the process returns to step 402, and the memory reference flag in the symbol table is set to T
If it is a RUE, a memory area having the size of the symbol table is set on the stack area, and the process returns to the step 402 (steps 407 and 408).

(5) If there is no unprocessed symbol table in step 402, it is checked whether or not the symbol table list being processed is a symbol table list of structure members. If the purchase is completed, the process is terminated. If the symbol table is a structure member symbol table, preparation is made to process the symbol table list to which the parent structure belongs in order to recursively process the structure member. After that, the process returns to the process from step 402 (steps 410 and 411).

By the processing of the embodiment of the present invention described above, the stack area in which the structure a declared in the program shown in FIG. 4 is allocated to the memory area becomes as shown in FIG. That is, in the case of the embodiment of the present invention, the x and y regions that are members of the structure a are allocated as the regions 802 and 803 on the stack region 801.

Next, the members of the structure in the source program described with reference to FIG. 5 are shown in FIG. 8 according to the structure reference analysis processing described with reference to FIG. 3 and the stack allocation processing described with reference to FIG. A flow in which such stack allocation is performed will be described.

First, after the structure reference analysis process is started, since there is an unprocessed statement in step 301, step 3
In step 02, the sentence 510 is extracted. Next, step 3
In 03, the statement 510 is not a memory reference statement of a local variable, so that the process returns to step 301. Step 3
In step 01, there are still unprocessed statements, so step 3
In step 02, the sentence 511 is extracted. Next, step 3
In step 03, the process proceeds to step 304 because the statement 511 is a memory reference statement of a local variable. Next, step 30
In step 4, since the sentence 511 is a reference to a structure, the process proceeds to step 305. Next, in step 305, since statement 511 is a reference to a structure member, step 3
Proceed to 06. Next, in step 306, the statement 511
Table 6 corresponding to the structure member x referenced in
Since the memory reference flag of 02 remains the initial value FALSE, the process proceeds to step 307. In step 307, after setting the memory reference flag of the symbol table 602 corresponding to the member x of the structure referred to in the statement 511 to TRUE,
The process returns to step 301.

In the same manner as described above, the process proceeds to step 307 for the statement 512, and the memory reference flag of the symbol table 603 corresponding to the member y of the structure referred to by the statement 512 is set to T.
RUE.

The statement 513 is also a memory reference of a local variable and is a reference to a structure member, as in the case of the statements 511 and 512. In step 306, both the symbol tables 602 and 603 have the memory reference flag already set. Since it is set to TRUE, the process returns to step 301.

When the processing of statement 513 is completed, step 3
In step 01, it is determined that there is no unprocessed statement, and the structure reference analysis process ends.

After the structure reference analysis process is completed, a stack allocation process is performed according to the processing procedure described with reference to FIG. First, in step 401, preparations are made for processing the symbol table list of func () shown in FIG. 5, which is a function being processed. The symbol table list includes the symbol table shown in FIG. Next, in step 402, since there is an unprocessed symbol table, the process proceeds to step 403. In step 403, the symbol table 601 is extracted as an unprocessed symbol table, and the flow advances to step 404. In step 404, the process proceeds to step 405 because the symbol table 601 is the symbol table of the structure. In step 405, the symbol table 6
Since the memory reference flag of 01 is FALSE, the process proceeds to step 409. In step 409, the symbol table 60
After preparing to process the symbol tables 602 to 604, which are the symbol table lists of the members of the structure indicated by 1, the process returns to step 402.

In step 402, since there is an unprocessed symbol table, the process proceeds to step 403 again. In step 403, the symbol table 602 is extracted as an unprocessed symbol table, and the flow advances to step 404. In step 404, since the symbol table 602 is not the symbol table of the structure, step 40
Go to 7. In step 407, the process proceeds to step 408 because the memory reference flag of the symbol table 602 is TRUE. In step 408, a process of taking the memory area 802 on the stack area 801 is performed.
Return to 02.

From the processing in step 402, the symbol table 602
In the same manner as in the case of (1), a process for taking the memory area 803 is performed on the symbol table 603. The same process is performed for the symbol table 604, but the symbol table 604 returns from step 407 to step 402 as it is because the memory reference flag is FALSE. When the processing of the symbol table 604 ends, in step 402, there is no unprocessed symbol table in the symbol table list of the members of the structure. In step 410, since the symbol table list is the symbol table list of the structure members, step 41
Proceed to 1. In step 411, after preparing to process the symbol table list to which the symbol table 601 of the structure a that is the parent structure of the structure member belongs, the process proceeds to step 402.
Return to After all the processes for the other symbol tables belonging to the function func () have been completed, the process proceeds from step 402 to step 410, where the process is terminated. The above-described embodiment of the present invention uses a simple structure as an example. As described above, the present invention is also applied to a nested structure in which a structure is defined in a structure, by using the inner structure and its members as the inner structure. be able to. Also, for the outer structure,
The present invention can be applied by treating the entire inner structure as one member of the outer structure.

In the embodiment of the present invention described above, FIG.
4 is a program for executing the processing described with reference to FIG.
D, MO, CDROM, DVD and other storage media,
It can be provided as a compilation system.

[0044]

As described above, according to the present invention, when allocating a stack area during compilation, it is not necessary to secure a memory area on the stack for members of a structure that is not referred to, so that useless stack area can be secured. Since it can be unnecessary, the stack area can be used in a directed manner.

[Brief description of the drawings]

FIG. 1 is a block diagram showing a configuration of a computer system on which a compiler according to an embodiment of the present invention operates.

FIG. 2 is a flowchart illustrating a compile processing operation.

FIG. 3 is a flowchart illustrating details of a processing operation of a structure reference analysis process.

FIG. 4 is a flowchart illustrating details of a processing operation of stack allocation processing.

FIG. 5 is a diagram illustrating an example of a source program.

FIG. 6 is a diagram illustrating an example of a symbol table generated from a source program.

FIG. 7 is a diagram showing an example in which a memory on a stack area is allocated to a structure according to the related art.

FIG. 8 is a diagram showing an example in which a memory on a stack area is allocated to a structure according to the embodiment of the present invention.

[Explanation of symbols]

 101 CPU 102 Display device 103 Keyboard 104 Main storage device 105 Compiler 106 Intermediate code 107 External storage device 108 Source program 108 Object program

Continued on the front page (72) Inventor Kenichi Tagami 5-2-1, Kamimizuhoncho, Kodaira-shi, Tokyo Within the Semiconductor Group, Hitachi, Ltd. (72) Inventor Yoshinori Hayakawa 6-81 Onoecho, Naka-ku, Yokohama-shi, Kanagawa Prefecture Address Hitachi Software Engineering Co., Ltd. In-house F-term (reference) 5B081 CC27

Claims (3)

[Claims] In a method of allocating a stack area of a compiler, when a memory area of a local variable of a structure is secured on the stack area, each of a plurality of members included in the structure is a member referred to. A stack area allocation method for a compiler, characterized in that a stack area is reserved for a member of a structure to be referred to and a stack area is not reserved for a member of a structure that is not referred to. 2. When a memory area for a local variable of a structure is secured on a stack area in a compiler, each of a plurality of members included in the structure is checked whether or not the member is a referenced member. Means,
Means for securing a stack area for a member of a referenced structure without securing a stack area for a member of a structure that is not referenced. 3. A processing program for checking whether or not each of a plurality of members included in a structure for realizing the compiler according to claim 2 is a member to be referred to, A storage medium storing a processing program for securing a stack area for a member of a referenced structure without securing a stack area for the member.