JP2002182926A - Compiling method and computer readable recording medium - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a compiling method to realize reduction of an object code and enhancement of execution performance without burdening a programmer. SOLUTION: The object code such as an assembly code is generated so that a compiler (compilation program) makes a group of variables into structure in an internal processing process of compilation (S4), a variable reference point in the source program is replaced with a member reference code of the structure (S5) and a memory address in the case of member reference is realized by the sum of the base address and offset (S6) by giving an instruction to the compiler so that a group of variables with mutually close reference points in the source program and to be frequently referred by the structure is grouped by the structure (S1). Grouping of global variables is possible without accompanying logical change of the existing source program itself, no description of a complicated structure member reference code is required, reduction of code size of a program and enhancement of practicability is realized.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a compile method for generating an object code from a source program using a computer system, and a recording medium storing the compile program. The present invention relates to a high-level language compiling technique that is effective when applied to a reduction in program size for a processor.

[0002]

2. Description of the Related Art C, one of high-level programming languages
To summarize the programming technique in a language, it is typical to first divide a process to be realized into a series of procedures, call a procedure as necessary, and perform the next process according to a calculation result. It is a processing flow. These procedures are sometimes called procedural languages because the calculations are performed through several variables. In C language, a procedure is also called a function. Variables can have several attributes to make programming easier. One of the attributes is the scope attribute, which is
It determines how the variable looks from each procedure, that is, how it can be accessed. As the scope attribute, for example, each time a function is invoked,
There are an automatic variable (auto) or a dynamic variable that disappears, an external variable (extern) as a global variable, a static variable (static) that continues to exist during the execution of the program, and the like.

Since a variable has its memory address according to a scope attribute, a C compiler must generate a variable access code according to the attribute.

In recent years, various microprocessors have been utilized in the field of embedded devices. Also in these microprocessors, programming in a high-level language such as C language is mainstream. As a microprocessor architecture often used in the field of embedded devices, there is a reduced instruction set computer (RISC) type microprocessor. This is also called a load-store architecture, because a series of calculations loads values from memory into registers on the processor, performs operations between registers on the processor, and stores the values of the registers that hold the operation results in memory. .

As a bit size of a register, 32 bits are often selected. Further, in the RISC type microprocessor, the instruction length is fixed, and the instruction length is 32 bits or 1 bit.
There is a 6-bit instruction. In the embedded field, it is desirable to reduce the program size as much as possible.
ISC-type microprocessors are also widely used. What is important in program development in the field of embedded microprocessors is to realize a given process with the smallest possible program code size,
To develop code that reduces the performance of the code itself, that is, the execution time. By setting the instruction length to 16 bits, the code size can be reduced in general, but the execution of multiple instructions is required to realize the required function, and the program size is increased and the performance is improved by increasing the number of instructions. Or not.

As a compiling technique for reducing the code size and further improving the execution speed of a program, there is, for example, a technique described in Japanese Patent Application Laid-Open No. 10-124325. In this method, a program is analyzed by a programming tool, variables that are frequently accessed are selected, and those are optimally arranged in a lower address area. In short, a variable with a high access frequency is arranged in an address area having a smaller addressing size. This means that the programmer has been assured that a global variable exists in a 16-bit partial address space (an address area with a small addressing size), but the lower-order address of the global variable (an address area with a small addressing size) Is assigned by the compiler.

[0007]

SUMMARY OF THE INVENTION The present inventor has proposed the RIS
The following study was made on the external variable reference technology in a C-type microprocessor, particularly a RISC-type microprocessor with a 16-bit fixed-length instruction.

For example, the following two methods can be considered as a method of generating an external variable access code in an individual object before being input to the linkage editor by the C compiler. 13 as an example, here, a global variable gvar is defined, and Ref1 in the function func is defined.
Referred to in the section. This reference Ref1 is a variable gvar
Is substituted into the register reg. Assuming that the C source file is once compiled into an assembly language source, there are two possible methods for implementing the reference code Ref1. One is when the address of the variable gvar cannot be embedded in the instruction as it is,
There are a method of determining the 32-bit address of the variable gvar before the load instruction (this is referred to as method A), and a method of embedding the 32-bit address in the load instruction itself (this is referred to as method B). For example, in the case of a 16-bit fixed instruction length RISC microprocessor, it is impossible to embed 32-bit address information in an instruction, so the A method must be adopted. Method B is an example of a method that can be employed in a microprocessor that executes a variable-length instruction.

The instruction "mo" of the code a1 in FIG.
“v.L Laddr, r0” is an instruction to load the 4-byte value at the memory address Laddr of the variable gvar into the register r0. In this instruction, the 4-byte value at the memory address Laddr is the memory address of the global variable gvar. This instruction requires access to the instruction itself when the instruction length is as short as 16 bits.
Since a 2-bit memory address cannot be embedded, a 32-bit memory address to be actually accessed is held in a memory area accessible by a 16-bit length instruction (allocated near an address Laddr). In the next instruction “mov.L @ r0, R1”, the value of the register r0 storing the memory address is read, and the read value is used as the memory address, and the value of the global variable gvar actually obtained therefrom is stored in the register r1. To load.

In code a1 of FIG. 13, reference Ref1 of the global variable in code 1 is realized by two load instructions and one memory area. In code a2 in FIG.
A machine language image when the assembly code is assembled is illustrated. Two load instructions "mov.L
.. "Are each 2 bytes, the memory area for storing the memory address of the global variable gvar is 4 bytes, and the code for implementing the reference code Ref1 requires a total of 8 bytes.

On the other hand, the code b1 in FIG.
A 32-bit memory address of the global variable gvar is embedded in the load instruction of the value of ar itself.
ar, r0 ”to register the value of the global variable gvar in the register r
0 can be loaded. The code b2 in FIG. 13 shows a machine language image when this assembly code is assembled. One load instruction “mov...” Is composed of a 2-byte main instruction and 4 bytes for storing the memory address of the global variable gvar.
The code for implementing f1 requires 6 bytes.

It can be said that the code b1 is smaller than the code a1 in terms of the code size. However, in a situation where the memory area “Laddr:. Since it can be regarded as 4 bytes, it cannot be unconditionally determined which of the codes a1 and b1 is better. Also, the code a1 has two load instructions for one global variable reference.
In contrast to the need to execute an instruction, the code b1 only needs to execute one load instruction. From the viewpoint of improving the execution performance of the program, it is desirable to implement the global variable reference with one load instruction.

As a result of the first study by the present inventors, when the number of bits of the address information is larger than the number of bits of the address information designation field of the instruction, as typified by a 16-bit fixed-length instruction, the variable is referred to. Requires a load instruction to load the address information of a variable into a register, a load instruction to read a variable from the address indicated by the value held by the register and load it into a destination register, etc. It is also necessary to have a memory area for holding the address information, and the code amount is increased, and the execution time of the process is prolonged.

Next, in order to reduce the code size in the method A, if the programmer gives a guarantee that the global variable is present in the 16-bit partial address space, the compiler operates in the memory area holding the memory address of the global variable. Can be changed from 32 bits to 16 bits. FIG.
Is an assembly code example in a case where a guarantee that the global variable gvar can be referred to by a 16-bit address is given, and a code a4 indicates a memory size required for the assembly. In this case, the code size required for global variable reference is reduced from 8 bytes to 6 bytes. Similarly, a code b3 in FIG. 14 shows an example of an assembly code of the method B in a case where the 16-bit address specification is guaranteed, and a memory size required for the assembly code is shown in a code b4. The code size required for global variable references is reduced from 6 bytes to 4 bytes.

That is, in the case of FIG.
Although the size is reduced from 8 bytes to 6 bytes, the size is not likely to be reduced, and the number of executed instructions is not reduced. Further, the method B has a variable-length instruction architecture, and cannot be adopted in a 16-bit fixed-length RISC microcomputer. As can be seen from this example, in the case of a program in which global variable accesses frequently occur, the program size of the RISC microprocessor having 16-bit fixed-length instructions is larger than the program size of the RISC microprocessor having a length of 32 bits or more. Also swells. The handling of global variables is extremely important for reducing the code size of a program and improving execution performance.

[0016] Based on the above, the results of the second study are described in
As represented by the technology described in Japanese Patent Application Laid-Open No. 124325/1992, the relationship with the number of bits of fixed-length instructions even when a compile technology in which a variable with a high access frequency is arranged in an address area with a smaller address designation is adopted. As a result, the present inventor has revealed that there is a limit in reducing the code size and further improving the execution speed of the program.

As a result of the third study, the present inventor has found that in order to reduce the addressing size, the number of bits of the instruction and the number of bits of the addressing field of the instruction are limited as in the 16-bit fixed-length RISC instruction. We found the advantage of compiling to use the base address and offset address when referring to variables in an instruction architecture. In short, grouping global variables whose reference points in a program are close to each other and are frequently referred to like a structure increases the chances of realizing performance improvement by reducing the code size and the number of executed instructions. .

On the other hand, as a fourth study result, the present inventor has found that, when grouping global variables by structure, when a programmer tries to describe the structure one by one in a source program, complicated structure members are required. It is assumed that reference codes must be written, and the concept of structuring by data type cannot be applied.Therefore, the readability of the program may be impaired, the burden on the programmer is enormous, and the It has been found that there is a possibility of causing a problem that it is likely to be a cause.

An object of the present invention is to provide a 16-bit fixed instruction length RISC capable of reducing the number of instructions required for global variable reference and the required memory area size, reducing the code size of a program, and improving the performance at the time of execution. It is an object of the present invention to provide a method for compiling a source program of a data processing device such as a type microprocessor, and a computer-readable recording medium for recording a compile program for implementing the method.

Another object of the present invention is to make a base address and an offset address available for variable reference without writing a complicated structure member reference code in a source program, and without impairing the readability of the meaning of the source program. A method of compiling object code of fixed-length instructions from a source program without placing a great burden on a programmer and causing a bug in the source program, and a computer-readable reading of a compile program realizing the compile method An object of the present invention is to provide a recording medium on which recording is possible.

The above and other objects and novel features of the present invention will become apparent from the description of the present specification and the accompanying drawings.

[0022]

The following is a brief description of an outline of a typical invention among the inventions disclosed in the present application.

[1] The compile method according to the present invention provides a compiler (compile program) such that variable groups such as global variables whose reference points in a source program are close to each other and are frequently referred to are grouped by a structure. (S1), the compiler structuring the group of variables designated in the internal processing of the compilation (S4), and replaces the variable reference location in the source program with the member reference code of the structure (S5). ), An object code such as an assembly code is generated so that the memory address at the time of member reference is realized by the sum of the base address and the offset (S6).

More specifically, a compiling method for generating an object code of a fixed-length instruction from a source program includes a process of detecting a grouping instruction for a group of variables that are not entirely related in the source program;
When detecting the grouping instruction, a process of grouping the variable group based on the instruction, a process of detecting a reference location of the grouped variable from a source program, and On the other hand, a process of generating an object code so as to refer to the variable by adding the offset address of the variable to the base address common to the group to which the variable belongs.

According to the above-mentioned method, global variables can be grouped without logically changing the existing source program itself, and the code size of the program can be reduced and the execution performance can be improved. Further, even if a complicated structure member reference code is not described, the compiler internally interprets the structure member reference code, so that the burden on the programmer is reduced and the readability of the source program itself is not impaired.

The above effect is particularly remarkable when the fixed-length instruction has a greater number of bits in the address information than the number of bits in the addressing field of the instruction.

[2] A computer-readable recording medium on which a compiled program is recorded in a computer-readable manner is a group for a variable group which is not entirely related in a source program in order to generate an object code of a fixed-length instruction from the source program. Processing for detecting an instruction for grouping, processing for grouping the variable group based on the instruction when the instruction for grouping is detected, and reference to a variable belonging to the same group that has been grouped, A compilation program is recorded in a computer-readable manner to execute a process of generating an object code corresponding to a variable reference by using an address obtained by adding a variable offset address to a base address common to the group.

By providing the compile program via the storage medium, processing by the compile program can be executed immediately, and global variables can be grouped without logically changing the existing source program itself. Thus, the code size of the program can be reduced and the execution performance can be improved. In addition, since the compiler internally interprets the structure member reference without writing complicated structure member reference codes, the burden on the programmer is reduced and the readability of the source program itself is not impaired. You can get to.

[3] Variables that are not associated as a whole in the source program are variable groups that are not entirely or partially defined as structures. Therefore, when reorganizing a variable group of discrete structure descriptions into a unified group, or reorganizing a variable group of a structure description and a non-structure variable group into a unified group Are also included in the scope of the present invention.

[4] In the first embodiment, the grouping instruction is given by a grouping instruction sentence included in the source program. Specifically, a method of designating a list of variables to be structured in each source file by a pragma statement (a directive statement P1 in the code C3 in FIG. 5). The programmer does not need to write a complicated structure member reference code even if the grouping directive is described in the source program.

A second aspect of the grouping instruction is given by a predetermined compile option, and the compile option is read by a grouping instruction file provided as a separate file other than the source program, and read by the read grouping instruction. Assume that grouping is performed on variables specified in the file. Specifically, a list of variables to be structured is described in one structuring instruction file (the directive P1 in the code C4 in FIG. 5), and the structuring instruction file is compiled when each source file is individually compiled. Specify in the compile option to read. Even if the programmer creates a structure instruction file separately from the source program, there is no need to write complicated structure member reference codes in the source program.

A third mode of the grouping instruction is given by a predetermined compile option, and the compile option is obtained by reading a grouping instruction file given as a separate file other than the source program;
It is assumed that the scanning of the variables of the source program specified by the read grouping instruction file and the grouping of the scanned variables are instructed. More specifically, the method does not require the programmer to specify a variable and issue a grouping instruction each time, and the compiler automatically recognizes a nearby external variable and forms a structure.

[5] In a fixed-length instruction such as 16 bits, there is a case where the restriction on the designated bit field size of the operand is large. Therefore, the group is adjusted according to the immediate field size of the load instruction with scaling immediate value of the target microprocessor. May be divided into a plurality of parts, and the compiler may have a function of packing many global variables in a memory area that can be referred to from one base address.

For example, the grouping process includes a process of creating a variable list in which variables to be processed are arranged in the order of data size, and using an immediate value of an object code as an offset address to be added to the base address. At this time, if necessary, a process of dividing the variables of the variable list into another group based on the relationship between the number of bits that can be taken by the immediate value of the object code and the number of bits of the offset address is included.

In the process of dividing the variables in the variable list into different groups, when the variables in the variable list are arranged in ascending order of data size based on the base address of the group, the offset with respect to the base address is The variable is divided into another group on the condition that it exceeds a specifiable range based on the immediate value of the object code.

The object code has an immediate value scaling function of multiplying the immediate value by an integer according to the data size to be referred to and adding it to the base address.

[6] The grouped variables are interpreted as members of a structure in a source program language,
A process of converting the access to the variable into a reference code to a structure member in the source program language and outputting the code to a source file may be further performed.

[0038]

DESCRIPTION OF THE PREFERRED EMBODIMENTS Outline of Compiling Method FIG. 2 illustrates a general procedure for generating an object code. First, a file 20 of a source program written in C language is compiled by a C compiler (compiler for a source program written in C language) 21. At this stage, each source file is compiled into an object module (a set of object codes such as assembly code) 22. In this state, addresses required for function calls and variable references between object files remain unresolved. Next, the linkage editor 24 resolves references to external names (external variable names, external function names) between the files to generate one virtual address space, and generates the load module 25. The names defined in the set of individual object files are given unique addresses in the virtual address space, and the code parts that refer to those names are embedded with the appropriate values and the logical values required for memory access at runtime. The address calculation instruction sequence is ready. When linking with the linkage editor 24, an object file prepared as the library 23 can be used together.

FIG. 3 illustrates a main part of a microprocessor for executing the load module. The load module 25 is stored in a memory (not shown) as an operation program of the microprocessor. The instructions constituting the program are 16-bit fixed-length instructions. Branch
The / decode unit U1 reads and decodes an instruction from the memory (not shown) via the instruction bus B1. The operation unit U2 reads the register from the register file U3 and performs the processing specified by the branch / decode unit U1. It is assumed that the register file U1 has 16 general-purpose registers having a 32-bit width. It is possible to have a floating-point register in addition to the general-purpose register. Although not shown in the figure, the operation result is also stored in a cache memory or the like via the data bus B2.

<< First Mode of Global Variable Grouping Processing >> When generating the object module 22 from the source program 20, the C compiler 21 detects a grouping instruction for a variable group that is not entirely related in the source program. At this time, the variable group is grouped based on the instruction, and the variables belonging to the same group are referred to using an address obtained by adding a variable offset address to a base address common to the group, Generate object code corresponding to variable reference. In short, a process is performed in which global variables are structured based on an instruction to group variables in the source program.

Before describing the global variable structuring process, a source code before considering the structuring process will be described with reference to FIG. 4 are global variables c0, c1,..., J5, j for various data types.
6 are defined. Function func of this source code
The operation exemplified by the code fragment Ref2 in parentheses means an operation of copying between global variables, that is, an operation of substituting the value of the variable d0 for the variable c0. Thus, the code fragment Ref of FIG.
Numeral 2 is for copying between global variables. When this is compiled into assembly code, it becomes a code fragment Ref3 in the code ASM1, and the global variable copy requires four memory access instructions. In general, load instructions load data from memory into registers,
It tends to take longer than the operation between registers, and it is desirable not to use a load instruction as much as possible from the viewpoint of improving the runtime performance. However, the code fragment R
In ef3, a load instruction is used to refer to the memory addresses of two global variables. Thus, FIG.
In a program in which global variable access frequently occurs, the number of instructions required for each global variable access and the required memory area size increase, the code size of the entire program increases, and the There is a concern that the performance of the device will also decrease.

On the other hand, when considering the global variable structuring process, the programmer accesses a plurality of global variables in the same function in the code C1 as exemplified in FIG. Based on the recognition that there is a tendency, these are grouped to reduce the code size and improve the runtime performance, and as shown in the code C3 in FIG. 5, the grouping directive P1 is added to the contents of the code C1. Add. The grouping directive P1 instructs the C compiler 21 to perform the same code generation processing as when the code C2 in FIG. 6 is input to the compiler.

FIG. 1 illustrates a compile process by the compiler 21 which has received a grouping instruction by the grouping instruction sentence P1 or the like. The compiler 21 performs internal processing indicated by the grouping directive P1 on the code C3 in FIG. 5 according to the algorithm shown in FIG. 1, and generates substantially the same code as in the case where the code C2 in FIG. 6 is an input source file. Then, the object module 22 is generated. Each source file including the grouping directive P1 and a normal source file not including the grouping directive P1 are compiled into an object module 22, and the linkage editor 24 determines the necessary functions in the library 23 and the object module 22. The link module is generated by linking.

The difference between the compiling method using the compiler 21 and the conventional compiling method is that the internal processing corresponding to the grouping directive P1 is performed according to the algorithm shown in FIG. 1 without requiring a structure description as a language specification. This will be described in detail.

The processing shown in FIG. 1 is performed for each source file. In step S1, the inside of the input source file is scanned to check whether the source file contains a grouping instruction P1. At this time, the grouping directive P1 may be described in the include file. Here, it is assumed that step S1 is performed after the normal preprocessing of the compiler. If the grouping instruction sentence P1 is not detected in step S1, the process proceeds to step S7, and the source file undergoes a normal compiling process.

If the grouping directive P1 is detected, the flow advances to step S2 to create a list of global variable names described in the directive P1. At this time, each global variable name has its data size as an attribute. The data size of each global variable name is obtained from the global variable reference declaration or definition statement of the C source file. For example, the data size of the variable name c0 in the grouping directive sentence group1 of the code C3 in FIG. 5 is “char” type from the global variable declaration “char c0, c1,...” In the C source file. As a result, a data size of 1 byte can be obtained. In this example, the declaration corresponding to the global variable name in the grouping directive P1 is a source file in which the grouping directive P1 is described, or
Must exist in the include file.

In step S3, each variable name list in the grouping directive P1 obtained in step S2 is rearranged by the size of the variable so that the variable name having the smaller data size comes first. For example, the directive gr in FIG.
In the case of up1, a variable whose name starts with c is 1 byte in size, a variable whose name starts with s is 2 bytes, and a variable whose name starts with i is 4 bytes. "S0, s1, s2, s3, s4, s
5, s6, c0, c1, c2, c3, c4, c5, c
6, i0, i1, i2, i3, i4, i5, i6 "are rearranged by size into" c0, c1, c2, c3, c4,
c5, c6, s0, s1, s2, s3, s4, s5, s
6, i0, i1, i2, i3, i4, i5, i6 ".

In step S4, each list is further divided as necessary in accordance with the immediate field size of the load instruction with scaling immediate which the target microprocessor has from each list obtained in step S3.
Interpret each split list as a structure. This is to reduce code size and improve runtime performance by packing many global variables in a memory area that can be referenced from one base address.

The load instruction with a scaling immediate has, for example, an instruction format and a source address calculation method shown in FIG. (1) is an example in which the source address is calculated by “register + offset”. Here, the instruction length is 16 bits, a field F1 indicates an opcode (operation code), and a field F2 indicates a target register Rn. Field F3 indicates base register Rm. Field F4 is an immediate field indicating an offset from the base register, and has a width of 4 bits. In this format, F4 is a field of a scaling immediate value and its size is 4 bits, so that up to 16 variables of the same size can be specified regardless of the data size of memory access. When the data sizes are mixed, as shown in (b), 16 1-byte data are arranged starting from the base address, followed by 8 2-byte data, and By arranging eight 4-byte data at the end, memory addresses at a maximum of 32 locations can be expressed by "one base register + scaling 4-bit immediate value". The state of the mapping by this is as shown in the memory area M3 of FIG.

For example, the load instruction “MOV.B @ (1,
R5), R0 "loads one byte of the data into the register R0 using the value obtained by scaling the value of the base register R5 and the immediate value 1 as the source memory address. In the load instruction with scaling immediate value, the source memory address is calculated by “(data size) × immediate value + base register”. In this case, the source memory address is calculated by “(1 byte) × 1 + R5”.
“MOV.W @ (1, R5), R0” is a load instruction with a scaling immediate value for loading 2 bytes of data. In this case, the source memory address is “(2 bytes) × 1 + R
5 ". Similarly, "MOV.L @ (1, R5),
“R0” is a load instruction with a scaling immediate value for loading 4 bytes of data. In this case, the source memory address is calculated by “(4 bytes) × 1 + R5”. By performing the immediate scaling in this way, even with a small immediate field size, the same number of offsets from the base register can be specified with an access size of 4 bytes, 2 bytes, and 1 byte.

FIG. 7B shows a load instruction “mov.
L Laddr, r0 ", the instruction length is 16 bits, the field F5 indicates the opcode, and the field F6 is the target register R.
represents n. Field F7 is an immediate field indicating an offset from the base register, and has an 8-bit width. The addressing mode of this instruction is so-called PC relative, and the source address is represented by the sum of the value (PC) of the program counter and an appropriate offset (disp).

Here, a specific example of the variable list structuring process in step S4 will be described. A specific example of dividing the variable list obtained in step S3 and interpreting each list as a structure will be described.

As a first example, group1, gr in FIG.
Consider up2. The elements of the variable list rearranged in the size order in step S3 are searched from the beginning, and up to 16 one-byte size variables are selected and registered as members of the structure g1. If it exceeds 16, another structure g2 is generated and the excess is registered as the first member of the structure g2. Otherwise, all structures g1
Register as a member of The memory image of the structure g1 is shown in the memory areas M1 and M2 in FIG. Grouping directive (pragma directive) group1 is converted to step S
When the processing is performed in steps S2, S3, and S4, the required structure becomes one, the C source image becomes Struct1 in FIG. 6, and the memory image becomes a memory area M1 in FIG. Similarly, when the pragma directive sentence group2 is processed in steps S2, S3, and S4, the required structure becomes one, and its C source image is Struc in FIG.
t2, and the memory image is the memory area M in FIG.
It looks like 2.

As a second example, consider group3 in FIG. In this case, 1-byte data c0,..., C7, d
0,..., D7 are arranged in a range from memory addresses _g3 to _g3 + 15. In the area after that, a 2-byte variable is stored from the base address of structure_g3 to 32.
(= 16 × 2) bytes.
In this case, we have already used up to _g3 + 15,
It will be arranged in the range from g3 + 16 to _g3 + 31. s0, ..., s6, and t0, and the next t
Since the offset becomes 32 bytes when 1 is to be arranged, a structure g4 is newly generated, and the remaining two-byte data variables t1,..., D6 are registered as members of the structure g4. Next, a 4-byte data size variable is set within a range not exceeding memory address_g3 + 64 (= 16 × 4) bytes.
Register in the structure g3. When i0,..., i6, j0 are registered in the structure g1, since up to the memory address_g1 + 63 bytes are utilized, the remaining variables j1,..., j6 are used as members of another structure g4 that has already been generated. register. When the group of variables of the grouping directive sentence group3 is grouped into a structure in step S4 as described above, 2
One structure g3, g4 is generated, and each memory image is represented by the memory area M3 and the memory area M4 in FIG. The global variable group to be the target of the grouping directive sentence group3 is, within the C compiler, two structures Struct3 and Struct4 shown in FIG.
Is interpreted as the same meaning.

If all the variables in the variable list are simply assigned to structure members in ascending order of size and realized by one structure, if there is a variable assigned outside the range of the 4-bit offset, the address of the variable The generation requires extra instructions, which is against the purpose of reducing the code size. On the other hand, the code size and the number of executed instructions are reduced by registering the members of the structure so as to increase the number of variables that can be accessed with a 4-bit scaling immediate value from one base address as in step S4.

If a C source code in which a global variable reference in a C source code including a grouping directive is converted into a structure reference is output by a compiler option, code maintenance, debugging processing, and the use of another compiler can be performed. Compilation is also possible.

Next, in step S5, the C source file is scanned from the beginning of the file, and a reference point to a global variable structured by a grouping directive is detected. When the input C source file is the code C3 in FIG. 5, as a reference location to the global variable grouped by the grouping directives group1 and group2, for example, the reference Re in FIG.
References to global variables c0 and d0 included in f2a can be detected. In order to realize these references by “structure base address + offset”, references to c0 and d0 are interpreted as references g1.c0 and g2.d0 to global structure members, respectively, as shown by Ref4 in FIG. . Actually, in the internal processing of the C compiler, the reference to the variable may be converted at the level of an intermediate language or the like so as to become a structure member reference. After ending Step 5 for the global variable reference in the input source file, normal C compilation processing is performed.

In step S6, a scaled immediate load / store instruction is used as part of the conventional code generation processing, particularly when generating a code corresponding to a structure member reference location. For example, the reference Ref inside the code C3 in FIG.
2 in step S5, reference Ref4 of code C2 in FIG.
Is generated, an instruction sequence as shown by reference Ref5 in the code ASM2 of FIG. 6B is generated. Base address of the structure (DATA.L_g1)
Etc. are already loaded, the load instruction of the structure base address is unnecessary.

In step S7, normal compile processing such as conversion into machine language is performed.

As described above, the grouping instruction statement gr in FIG.
An object module with reduced code size and improved execution-time performance with respect to global variable reference in code C3 including up1 and group2 is obtained. Similarly, when the grouping directive P3 of FIG. 5B is used, the code size can be reduced and the execution performance can be improved.

The same processing is performed for other compilation targets. For example, the grouping instruction statement grou of the code C3
When a global variable included in p1 is referred to by another C source file, a grouping directive is also described in the C source file, so that a global variable grouped among all files can be obtained. Access code integrity is maintained.

As described above, the result of processing by the grouping directive is substantially the same as the result of compiling a source program having a structure description as a language specification. For example, a code having the same function as the code C1 in FIG. 4 and having the required number of instructions and the required memory area smaller than the code C1 has the same result as the code C2 in FIG. Can be obtained. The code C2 in FIG. 6 represents the global variables defined individually in the code C1 as 2
Two structures Struct1 and Struct2 are grouped, and each global variable reference of the code C1 is realized by a code member reference of the structure C2. The same function as the code fragment Ref2 of the code C1 is realized by the code fragment Ref4 of the code C2. An assembly code obtained by compiling the code fragment Ref4 is indicated by a code fragment Ref5 in the code ASM2. Here, for example, the memory address of the member d0 of the global structure variable G2 is loaded into the register R5 based on the memory address “_g2” of the global structure variable G2, and the offset therefrom is represented by an immediate value. + Immediate value ". The base is a 32-bit address, and if the offset has a range that can be expressed by, for example, a 4-bit size, 16 memory addresses can be specified. The member d0 is the first member of the structure G2, and the offset is 0. Similarly, code C
1 corresponding to the global variable c0 of the member G0 of the structure G1.
And the memory address of c0 is also the global structure variable G1
Register R4 based on the memory address “_g1” of
, And the offset therefrom is represented by an immediate value, and is generated by “base register + immediate value”.

In the code fragment Ref5 of the code C2, the reference to the variable d0 can be realized by loading the base of the structure variable in advance and using one memory access instruction with an immediate value. In the code fragment Ref5, the function that required a byte can be realized with two instructions and a memory area of 0 byte.

When the case where the grouping directive according to the present invention is used is compared with the case where the structure description in the C language specification is made as shown in FIG. 6, the compile results are substantially the same, but the source In terms of the burden on the programmer who creates the program, the former requires the C compiler to interpret the grouping directive internally as a structure member reference without writing complicated structure member reference codes. This has an advantageous effect that the burden is reduced and the readability of the C source program itself is not impaired. Also, under the constraint that the number of bits in the addressing field of the instruction is smaller than the number of bits of the address information, as represented by a 16-bit fixed-length instruction, the code size of the program is reduced and the performance during execution is improved If you are not aware of the problem, it is meaningless as a concept of a structure that induces bugs or sacrifices readability, and it is difficult for ordinary programmers to write a structure description that simply complicates the description. This is contrary to common technical knowledge. Therefore, even if it is against such common technical knowledge, the adoption of the structure description as shown in FIG. 6 cannot be easily achieved without motivation to do so. in short,
The configuration shown in FIG. 6 is description content that can be realized only from the same viewpoint as the opportunity of the present invention, and cannot itself be easily conceived.

FIG. 10 shows a comparison example of the total code size and the number of executed instructions according to the grouping, method A, and method B according to the present invention.

When the memory address is realized with a general 32-bit length in the code C1, the code size according to the method A shown in (A) requires 336 bytes as shown in the column of addr32, and shown in (B). The number of executable instructions according to the method A is 8 as shown in the column of addr32.
Four instructions are required. In contrast, when a global variable is structured by a grouping directive (in this case, code C
(Comparable to the case where global variables are grouped by structure as in FIG. 2), the code size is “method A + g” in (A).
As shown in the column of addr32 of “loop”, 98 bytes are required, and the number of execution instructions is “method A + gro” in (B).
As shown in the "up" column, 44 instructions are required. That is, the structuring reduces the code size to about / and the number of executed instructions to about ２. Method B is based on a microprocessor that supports variable-length instructions, but “Method B” and “Method A + grou” in FIG.
Looking at the column of addr32 of "p", "method A + grou
It can be seen that "p" requires a smaller code size.
Also, “method B” and “method A + grou” in (B)
Looking at the column of addr32 of "p", "method A + grou
It can be seen that the number of execution instructions of “p” is equivalent to that of “method B”. Further, even if the address is guaranteed to be 16 bits, the superiority of “method A + group” can be similarly understood from FIG.

As described above, according to the C compiler for structuring global variables according to the global variable grouping directive of the present invention, the existing C source program itself is not logically changed. Global variables can be grouped, and the code size of the program can be reduced and the execution performance can be improved. Further, even if a complicated structure member reference code is not described, the C compiler internally interprets it as a structure member reference, so that the load on the C programmer is reduced and the readability of the C source program itself is not impaired. .

<< Second Aspect of Global Variable Grouping >> Still another example in which global variables are structured based on a grouping instruction from a programmer will be described. FIG. 5 (A),
In the example of (B), grouping of global variables is performed by grouping directives P1 and gro in individual C source program files.
Up3 is described, but as another implementation method, it is also possible to describe a grouping directive in an include file as shown in FIG. 5C.
A compile option that refers to an include file that describes a grouping directive is provided in the C compiler.
By compiling with the option to read this include file when compiling an individual C source file, the code size can be reduced and the execution performance can be reduced, as in the case where the grouping directive is written directly in the C source file. Can generate improved objects. In the case of the grouping instruction method using this separate file, the programmer does not need to embed the grouping instruction statement in the individual C source file, and the consistency of the access code to the global variables grouped between all the files is simplified. Is kept.

<< Third Aspect of Global Variable Grouping Process >> Another example in which the programmer does not have to issue a grouping instruction each time will be described. The compiler specifies a C source file and an include file to be compiled with a compile option. The compiler generates a code in which global variables in the specified file are structured according to the flow of FIG. In step S1,
The C source files are scanned in the order specified by the compile option, and the definition names of the scalar type external variables are listed for each size. For example, if the file to be scanned first is composed of the code C1 in FIG. 4, the list of definition names of byte-size scalar type external variables is “{c0, c
1, c2, c3, c4, c5, c6, d0, d1, d
2, d3, d4, d5, d6} ”, and the list of definition names of scalar type external variables of 2 byte size is“ {s0,
s1, s2, s3, s4, s5, s6, t0, t1, t
2, t3, t4, t5, t6} ”, and the list of definition names of the 4-byte scalar type external variable is“ {i0,
i1, i2, i3, i4, i5, i6, j0, j1, j
2, j3, j4, j5, j6} ". It scans the next source file and extends these lists.

In step S2, the list is divided based on the list obtained in step S1 and assigned to structures. Here, almost as much as possible in the memory area that can be referred to from one base address in accordance with the immediate field size of the scaling immediate load instruction of the target microprocessor, almost as described in step S4 of FIG. Pack global variables. As a result, a global variable structure as shown in code C2 in FIG. 6 is obtained from the definition name of the scalar type external variable obtained from the file including the code C1 in FIG.

In step S3, an internal expression of a compiler process is obtained in which the external variable reference portion of each input file is replaced with the member reference of the structure obtained in step S2.
This internal representation is almost the same as a normal compilation of the source code of FIG.

In step S4, the structure member reference replaced in step S3 is subjected to code generation utilizing a load / store instruction with a scaling immediate value.

As described above, even when the programmer does not instruct the structuring of global variables, an object module can be obtained in which the grouping of global variables and the code size are reduced to some extent, and the runtime performance is improved. In the example of FIG. 11, the structure is structured in the order in which the global variables appear in the file without access frequency prediction. However, if the list obtained in step S11 is rearranged based on access frequency prediction by simulation or the like, the code size can be reduced. It is possible to generate an object with a reduced size and improved runtime performance.

<< Compilation Program Recording Medium >> FIG.
2 exemplifies a program development system that realizes the compiling method shown in FIGS. The system shown in FIG. 1 is realized by an engineering workstation or a personal computer system, and has a keyboard 1 as input means, a display 2 as display means, a CPU board and an interface board on which a CPU 3A and a main memory 3B are mounted. It comprises a computer unit 3 as data processing means, an auxiliary storage device 4, and a communication interface circuit 5 such as a terminal adapter or a modem. The communication interface circuit 5 also forms an example of an input unit. The auxiliary storage device 4 includes, but is not limited to, a hard disk device having a fixed magnetic disk, a memory card device to which a flash memory card can be attached and detached, and a floppy disk drive that can read and write from a floppy (registered trademark) disk. Device, CD-ROM drive capable of reading CD-ROM, M capable of reading / writing to MO disk
It is composed of an O drive device and the like. 4A is a general term for recording media of the auxiliary storage device 4. The auxiliary storage device 4 also forms an example of an input unit. The communication interface circuit 5 can be connected to a public line network 6 or the like. Although not particularly limited, the CPU 3A loads a program read from the recording medium 4A or a program downloaded via the communication interface unit 5 into the main memory 3B or the like and executes it. Data necessary for executing the program is read from the recording medium 4 or downloaded using the communication interface 5 and further input from the keyboard 1.

In the program development system, the auxiliary storage device 4 or the communication interface circuit 5 can input the source program and the like.

An operation program for the computer unit 3 to perform the compiling process is provided on a computer-readable recording medium 4A. This program is configured by machine language necessary for the computer unit 3 to execute the processing described in FIG. 1 and FIG. By providing a necessary program via the recording medium 4A, it becomes easy to realize the compiling method by a computer.

Although the invention made by the present inventor has been specifically described based on the embodiment, it is needless to say that the present invention is not limited to the embodiment and can be variously modified without departing from the gist thereof. No.

For example, in the source program, variables that are not associated as a whole may be variables that are not entirely defined as structures, or variables that are partially defined as structures. Good. Therefore, when reorganizing a variable group of discrete structure descriptions into a unified group, or reorganizing a variable group of a structure description and a non-structure variable group into a unified group The present invention is also applicable.

The contents of the source program are not limited to the above example. The addressing mode such as register relative is not limited to the addressing mode represented by the load instruction with a scaling immediate value, and may not have the scaling immediate value.

[0080]

The effects obtained by typical ones of the inventions disclosed in the present application will be briefly described as follows.

In the source program, structuring processing is performed by giving a grouping instruction to a group of variables that are not entirely related to each other, and a variable offset address is added to a base address common to the group to which the variable belongs. Since the variable reference is realized, it is possible to reduce the number of instructions required for the variable reference and the required memory area size, reduce the code size of the program, and improve the performance at the time of execution.

When making the base address and offset address available for variable reference, the programmer does not need to describe the structure in the source program.
The source program does not include complicated structure member reference codes, does not impair the readability of the meaning of the source program, does not impose a large burden on the programmer, and has no risk of inducing a bug in the source program. Can be realized.

Since the group can be divided into a plurality of groups in accordance with the immediate field size of the load instruction with immediate scaling of the target microprocessor, packing many global variables in a memory area that can be referred to from one base address. Becomes possible.

[Brief description of the drawings]

FIG. 1 is a flowchart illustrating an example of a compiling method according to the present invention.

FIG. 2 is a flowchart illustrating a generation procedure from generation of a load module to a source program.

FIG. 3 is a block diagram illustrating a main part of a microprocessor that executes the load module.

FIG. 4 is an explanatory diagram exemplifying a source code and an assembly code before considering a global variable structuring process.

FIG. 5 is an explanatory diagram illustrating a source program and a grouping directive.

FIG. 6 is an explanatory diagram illustrating a source program having a structure description and its assembly code.

FIG. 7 is an explanatory diagram illustrating an instruction format of a load instruction with a scaling immediate value and a source address calculating method using the immediate value;

FIG. 8 is an explanatory diagram showing an example of a global variable division method using a load instruction with a scaling immediate value.

FIG. 9 is an explanatory diagram showing another example of a global variable division method using a load instruction with a scaling immediate value.

FIG. 10 is an explanatory diagram comparing the overall code size and the number of executed instructions according to each of the grouping instruction method, method A, and method B.

FIG. 11 is a flowchart illustrating another example of the global variable grouping process.

FIG. 12 is a system configuration diagram illustrating a program development system for realizing the compiling method of FIG. 1;

FIG. 13 is an explanatory diagram of a global variable access code having an address of 32 bits.

FIG. 14 is an explanatory diagram of a global variable access code having an address of 16 bits.

[Explanation of symbols]

S1, S2,..., S7 Steps indicating global variable grouping processing 20 Source program 21 C compiler 22 Object module 24 Linkage editor 25 Load module Ref1, Ref2,. Struct4
Structure representation example group1, group2, group3, P1 Grouping directive F1 Operation code field F2 Target register specification field F3 Base register specification field F4 Immediate field 3 Computer unit 3A CPU 3B Main memory 4 Auxiliary storage device 4A Recording medium

Claims (19)

[Claims] 1. A compiling method for generating object code of fixed-length instructions from a source program, comprising: a process of detecting a grouping instruction for a group of variables that are not entirely related in the source program; When detecting, a process of grouping the variable group based on the instruction, a process of detecting a reference location of the grouped variable from a source program, and a process in which the variable belongs to the detected variable reference location. A process of generating an object code so as to add a variable offset address to a base address common to the group and to refer to the variable. 2. The compiling method according to claim 1, wherein said fixed-length instruction has a bit number of address information larger than a bit number of an address designation field of the instruction. 3. The compiling method according to claim 1, wherein the variables that are not related as a whole in the source program are a group of variables not entirely or partially defined as a structure. 4. The compiling method according to claim 1, wherein the grouping instruction is given by a grouping instruction sentence included in a source program. 5. The grouping instruction is given by a predetermined compile option, and the compile option is read by reading a grouping instruction file given as another file other than the source program, and specified by the read grouping instruction file. 2. The compiling method according to claim 1, wherein grouping is performed on variables to be performed. 6. The grouping instruction is given by a predetermined compile option, and the compile option is read by reading a grouping instruction file given as another file other than the source program, and specified by the read grouping instruction file. 2. The compiling method according to claim 1, wherein scanning of the variables of the source program to be performed and grouping of the scanned variables are instructed. 7. The grouping process includes a process of creating a variable list in which variables to be processed are rearranged in the order of data size, and using an immediate value of an object code as an offset address to be added to the base address. And, if necessary, dividing the variables in the variable list into another group based on the relationship between the number of bits that can be taken by the immediate value of the object code and the number of bits of the offset address. 7. The compiling method according to any one of items 2 to 6. 8. The process of dividing the variables in the variable list into different groups includes the step of arranging the variables in the variable list in ascending order of data size based on the base address of the group. 8. The compiling method according to claim 7, wherein the variable is divided into another group on condition that the offset exceeds a range that can be specified based on the immediate value of the object code. 9. The compiling method according to claim 8, wherein the object code has an immediate value scaling function of multiplying an immediate value by an integer according to a data size to be referenced and adding the result to a base address. 10. Interpreting the grouped variables as a member of a structure in a source program language, converting access to the variable into a reference code to a structure member in the source program language, and outputting the code to a source file 7. The compiling method according to claim 1, further comprising the step of: 11. A process for detecting a grouping instruction for a group of variables that are not entirely related in a source program in order to generate an object code of a fixed-length instruction from a source program, and when the grouping instruction is detected. In the process of grouping the variable groups based on the instruction, and for referring to the variables belonging to the same group that has been grouped, an address obtained by adding a variable offset address to a base address common to the group is used. A computer-readable recording medium storing a compile program for executing a process of generating an object code corresponding to a variable reference. 12. The computer-readable recording medium according to claim 11, wherein the fixed-length instruction has a bit number of address information larger than a bit number of an address designation field of the instruction. 13. The variable which is not associated as a whole in the source program is a variable group not entirely or partially defined as a structure.
The computer-readable recording medium according to claim 1. 14. The computer-readable recording medium according to claim 11, wherein the instruction for grouping is given by a grouping instruction sentence included in a source program. 15. The grouping instruction is given by a predetermined compile option, and the compile option is read by a grouping instruction file provided as a separate file other than the source program, and specified by the read grouping instruction file. 12. The computer-readable recording medium according to claim 11, wherein the instructions indicate grouping of the variables to be performed. 16. The grouping instruction is given by a predetermined compile option. The compile option is read by reading a grouping instruction file given as another file other than the source program, and specified by the read grouping instruction file. 12. The computer-readable recording medium according to claim 11, wherein instructions for scanning the variables of the source program to be performed and grouping the scanned variables are provided. 17. The grouping process includes a process of creating a variable list in which variables to be processed are rearranged in order of data size, and using an immediate value of an object code as an offset address to be added to the base address. And, if necessary, dividing a variable in a variable list into another group based on a relationship between the number of bits that can be taken by an immediate value of the object code and the number of bits of the offset address. 12. The computer-readable recording medium according to item 11. 18. The process of dividing the variables in the variable list into different groups includes the step of arranging the variables in the variable list in ascending order of data size based on the base address of the group. 18. The computer-readable recording medium according to claim 17, wherein the variable is divided into another group on condition that the offset exceeds a range that can be specified based on the immediate value of the object code. 19. The computer-readable recording according to claim 18, wherein said object code has an immediate value scaling function of multiplying an immediate value by an integer according to a data size to be referenced and adding the result to a base address. Medium.