JPH0390931A - Generation of rom transformation program - Google Patents

Abstract

PURPOSE:To attain the effective use of a memory area and at the same time to omit the manual jobs for improvement of the program generation efficiency by allocating a variable having the initial value to an original position in a linker connection process and moving the initial value of the variable to a point right after a non-changed area at output of a load module. CONSTITUTION:A variable having the initial value is assigned to its original position in a linker connection process and then assigned to an area starting at an address shown by a specific symbol set right after a non-changed data on a non-changed area in a subsequent output process. Then a ROM transformation program is generated with all data on a non-changed area defined as those to be written into a ROM as they are. As a result, no useless part is generated in the continuous areas of data in the non-changed area. Then a desired ROM transformation program is generated when the data outputted via a linker are just defined as those to be written into the ROM as they are. Thus the program generation efficiency is improved.

Description

[Detailed Description of the Invention] [Summary] Regarding a method for generating a ROMized program, a ROMized program is provided that eliminates wasted memory area and aims for effective use, and improves efficiency by eliminating manual work when generating a ROMized program. The purpose is to provide a generation method that uses a linker to combine multiple object programs in a memory area that has an unchanged area and a changed area to generate a load module. Unchanged data is allocated to the unchanged area, variables and variables with the first M(a') are allocated to the changed area, and when the program generated in the load module is converted to ROM, the unchanged parameters are Only variables with initial values are written as ROM contents, and RO
A method for generating a ROMized program that generates an Mized program includes a step of allocating a variable having the initial value to an area starting from an address indicated by a specific symbol immediately after unchanged data in an unchanged area; The method is configured to include the step of generating a ROMized program by using the data in the unchanged area including the updated contents as output from the linker.

[Industrial application field]

The present invention relates to a method for generating a ROMized program, and more particularly, to a method for generating a ROMized program in which the memory arrangement is improved when a linker generates a program to be converted into a ROM.

In software development, large-scale programs are divided into multiple parts and compiled.

In this split compilation, functions and variables are placed in separate files, resulting in symbols that cannot be resolved in a single file. To solve this problem, a linker is used to perform the binding process.

Here, the process of generating one executable program from one or more object programs is called linking or concatenated editing, and the program that performs this process is called a linker.

A linker generates an executable program.

A linker takes multiple objects as input and outputs one executable program, and uses a combination process to search for unresolved symbols and resolve each one. An executable program is generated only when all unresolved symbols are resolved. However, in order to resolve unresolved symbols, the positional relationship of each symbol must be determined.

Furthermore, one of the functions required of the linker is a memory allocation function. This memory allocation function is divided into "unchanged areas" such as program sources and constants, "changed areas" such as variables that do not have initial values, and "initialized areas" such as variables that are changed but have initial values. The change area is divided into three areas: ``Change areas with value .'', and each area is assigned to a continuous area.

When converting to ROM, R is applied only to areas with initial values, that is, "unchanged areas" and "changed areas with initial values."
Write as OM.

The technical background of the present invention is a method for generating a program to be stored in a ROM.

[Conventional technology]

To explain the conventional method of generating a ROMized program, when a linker is used to create a ROMized program, the following method is used. FIG. 6 is a diagram showing the process.

A program 1 shown in FIG. 6 is a source code (Cod
e), constant (Const), variable with initial value (V
arl), change without initial value (Var2), and the configuration of the memory that stores the program 1 is 0000.
(Refers to the address. The same applies hereafter) to 2000 is RO
Assume that M, 2000 to 4000 are composed of RAM.

In this program 1, since Codd + Con5t is an unchanged area, 200 from oooo in the ROM area
0 and Varl + Var2 may be changed, so they are allocated to address 2000 and later in the RAM a area (see FIG. 6(a)). Then, the output to the linker is output according to this allocation (see FIG. 6(b)). Also,
When writing to ROM, Codd in the unchanged area
.

Con5t and Varl of the change area having the initial value are written individually (see FIG. 6(C)). At runtime, the area starting from address 2000 needs to be RAM, so the Varl area is sometimes 20 ROM allocated.
It is necessary to allocate it to a different area from address 00.

Normally, ROM allocation is done by writing the output value of Varl output to the area starting from address 2000 to the ROM, and
When allocating the address, a method is used in which the address is manually shifted to a specified address (see Figure 6(d)).

Also, during execution, the area from address 2000 is Varl.
Since the initial value of Varl is required, the initial value of Varl allocated to the ROM is copied to the area starting from address 2000 before program execution (see FIG. 6(e)).

Note that the linker processing described above is roughly divided into four parts, which are represented by the flowchart shown in FIG. 7.8.

FIG. 7 is a flowchart showing the processing of a conventional general linker, and FIG. 8 is a flowchart showing the output processing of a load module.

First, in the object input in step Sl, all objects to be linked are input, and the external reference table,
Create an externally defined table. Next, in area allocation in step S2, the designated area is allocated to the input object. Thereafter, in symbol resolution in step S3, unresolved symbols such as external references are resolved and a load module is created. When all unresolved symbols have been resolved, the created load module is output in step S4, and the linker processing is terminated. The actual load module is composed of a plurality of memory image data records or one memory image data record, and the memory image data record is, for example, the 9th memory image data record.
The format is as shown in the figure. In this case, Address part 2: Information of the address where the memory image data is to be loaded Record length 3: Length of the memory image data Memory image data 4: Data of the memory image to be expanded (length is arbitrary) , the address part 2 indicates the address where the data 4 of the memory image is to be loaded, and the record length 3 indicates the length of the memory image data 4. Therefore, the output of the load module is the address where the data 4 of the memory image is to be loaded. All records will be output, and the process is as shown in the flowchart in Figure 1. In step S, it is determined whether or not the section ends. If NO, in step S6 all memory belonging to the section is output. This is done by outputting an image data record.

[Problem to be solved by the invention]

However, in this conventional ROM program generation method, a variable (Varl) with an initial value is written to a certain area in the ROM area, but that area is copied to the RAM area when the program starts. Since it is necessary, this copy processing is added to the beginning of the program. Therefore, when creating a program, it is necessary to determine the starting position of a variable (Varl) with an initial value in the ROM, but it is also necessary to determine the starting position of a variable (Varl) with an initial value in the ROM.
Const) is unknown until the joining process is completed. Therefore, variables with initial values (Varl) are stored in a fixed area (memory code (Code) %constant (Con) in advance.
The size of st) is predicted and written in the area after that area (starting from address 1000 in FIG. 6). At this time,
Code, C.

Since area 5 (hunting part in Figure 6(d)) is provided between the nst area and the Varl area at a fixed address, there is a problem that this area 5 is wasted in terms of effective memory utilization. .

In addition, when conventionally outputting an area with an initial value such as Varl, after writing to the ROM, the ROM allocation was done manually by shifting the address (see Figure 6 (c).
) (d)), there was a problem that it required troublesome manual work, was troublesome, and was inefficient.

Therefore, the present invention allocates variables with initial values to their original positions (changed areas) during linker binding processing, and assigns initial values of variables with initial values to unchanged areas when outputting a load module. By moving and outputting immediately after
In addition to eliminating wasted areas of memory and making effective use of it,
It is an object of the present invention to provide a method for generating a ROMized program that can eliminate manual work and improve efficiency when generating a ROMized program.

[Means to solve the problem]

In order to achieve the above object, the method for generating a ROM program according to the present invention generates a load module by combining a plurality of object programs using a linker in a memory area having an unchanged area and a changed area. Unchanged data such as program sources and constants are allocated to the unchanged area, variables and variables that are changed but have initial values are allocated to the changed area, and the program created in the load module is transferred to the RO.
When converting to M, only the unchanged parameters and variables with initial values are written as ROM contents,
A method for generating a ROMized program that generates a ROMized program includes a step of allocating a variable having the initial value to an area starting from an address indicated by a specific symbol immediately after unchanged data in an unchanged area; The method includes the step of generating a ROMized program by using the data in the unchanged area including the updated contents as output from the linker.

[Operation] In the present invention, variables with initial values are assigned to their original positions (changed areas) during the linker's linking process, and are assigned to specific symbols immediately after unchanged data in unchanged areas during subsequent output. A ROM program is generated as data that is allocated to an area starting from the displayed address, and all data in the unchanged area is to be written as is into the ROM.

Therefore, in the non-change area, there is no wasted part in the series of data areas, and it is possible to generate the desired ROM program by simply using the data output by the linker as data to be written to the ROM. Improves efficiency.

〔Example〕

Hereinafter, the present invention will be explained based on the drawings.

1 to 5 are diagrams showing an embodiment of a method for generating a ROMized program according to the present invention. FIG. 1 is an overall configuration diagram of a device that implements the ROM program generation method. In this diagram, numeral 11 is a central processing unit that performs various arithmetic processing, for example, compiling a source program for a language processing system. The object program 12 is generated and stored in the external storage device 13, and the memory 14 is used as a work area for the linker, and the linker connects multiple object programs. An executable program is created by filling in the part and stored in the external storage device 13 as a load module 15.

16 is a terminal device, such as a keyboard;
On top of the terminal device 16 is a display 1 consisting of a CRT or the like.
7 is installed.

In the above configuration, FIG. 2 is a flowchart of linker processing, and FIG. 3 is a diagram showing a ROMization program generation process.

In FIG. 2, an object to be processed by the linker is input in step S11, and a designated area is allocated in step SI2. These step processes are similar to those of the conventional example, and the process is shown in FIG. 3(a).

Next, in step S, it is determined whether or not to perform ROMization,
If ROMization is to be performed, the process proceeds to step S; otherwise, the process jumps to step SI4 and proceeds to step SIS.

In step S, a specific symbol (Varls) is generated as a process after the generation of a specific symbol, that is, the area is allocated.
The address immediately after the source code (Code) and constant (Const) area is assigned to , and this information is added to the external definition table (see FIG. 3(b)).

Thereafter, symbol resolution processing is performed in step SI5.

The characteristics at this time include specific symbols (Varls
) but does not change the actual area. Symbol resolution processing is performed as the area remains the specified area. The area is changed in the load module output process described next.

Next, in the load module output process of step S16, a process of shifting the area is performed. Details of this process are shown in the flowchart of FIG. First, Step 7 S21
It is determined whether the section being processed has ended or not, and if it has not ended, the object currently being linked is converted to ROM in step S2□, and the output section is set to a variable with an initial value. It is determined whether or not it is an area (Varl), and if YES, the address part of the memory image data record is converted into the source code (
Code) and immediately after the constant (Const) area. As a result, the configuration of the load module to be output is such that the areas of source code (Code), constants (Const), and variables with initial values (Varl) are arranged consecutively. Note that, taking the layout shown in FIG. 3(a) as an example, the memory image data record at the time when symbol resolution is completed is shown as shown in FIG. 5(a). Next, in step SZ4, all memory image data records belonging to the section are outputted. On the other hand, in step S2□
If o, jump to step S23 and proceed to step SZ.
Proceed to step 4. Therefore, in step Sza, the load module is outputted, and at the time of outputting, Code
, Con5t (first and second memory image data records) are output without changing the address part, and for Varl, the address part is changed from 2000 to 0FOO, which is the address immediately after the code and constant area, and output. do. This state is shown in FIG. 5(b).

In order to clearly explain the generation of a ROMized program based on the above flow process, referring to FIG. (C.

n5t), a variable with an initial value (Varl), and a variable without an initial value (Var2).The structure of the memory that stores program 1 is ROM from address oooo to address 2000, and from address 2000 to address 4000. R
Suppose that it is composed of AM. The linker performs memory allocation similar to the conventional method, as shown in FIG. 3(a). In the output of the linker, by using the function of this embodiment that allocates different areas during the join process and when outputting, Var is assigned immediately after the Code and Con5t areas.
1 (see FIG. 3(b)). When writing to the ROM, the three consecutive output areas are written as they are (see FIG. 3(c)). Since the state written in the ROM is the same as the state when it is allocated, the ROM is allocated as is (see FIG. 3(d)). Next, as in the conventional example, the initial g value of Varl allocated to the ROM before program execution is copied to the area starting from address 2000 (see FIG. 3(e)). Here, by using a specific symbol in this copy process,
The initial address of Varl (Ii! area) on the ROM can be used.

In this way, the wasted area of ROM is eliminated and the ROM
Allocation can sometimes eliminate the troublesome task of shifting addresses. As a result, memory can be used effectively and the efficiency of ROM program generation can be improved.

〔Effect of the invention〕

According to the present invention, when generating a ROMized program, it is possible to eliminate wasted areas of memory (unchanged areas) and make effective use of the memory, and it is also possible to improve efficiency by eliminating troublesome manual work.

[Brief explanation of drawings]

1 to 5 are diagrams showing an embodiment of the ROM program generation method according to the present invention, FIG. 1 is an overall configuration diagram of a device that implements the ROM program generation method, and FIG. A flowchart of the linker processing, Fig. 3 is a diagram explaining the process, Fig. 4 is a flowchart of the load module output processing, Fig. 5 is a diagram showing the memory image data record, and Figs. 6 to 9 are diagrams explaining the process. FIG. 6 is a diagram explaining the process, FIG. 7 is a flowchart of linker processing, FIG. 8 is a flowchart of the load module output and processing, and FIG. 9 is a diagram showing a method of generating a ROM program. It is a figure which shows the memory image data record. 1...Program, 11...Central processing unit, 12...Object program, 13...
...External storage device, 14...Memory, 15...Load module, 16...Terminal device, 17...Display. Flowchart of linker processing in one embodiment Figure 2 Flowchart of load module output processing in example 231 Figure C-chart of conventional linker processing Figure Address section length Memory image data in example Address section Diagram showing long data record Flowchart of conventional load module output processing Diagram showing conventional /mori image data record

Claims (1)

[Claims] A load module is generated by combining multiple object programs using a linker in a memory area that has an unchanged area and a changed area, and unchanged data such as program sources and constants are generated during the linker's combining process. are allocated to the unchanged area, variables and variables that are changed but have initial values are allocated to the changed area, and when the program generated in the load module is converted to ROM, the unchanged parameters and variables with initial values are allocated Only write as ROM contents, ROM
A method for generating a ROMized program that generates a ROMized program includes the steps of allocating a variable having the initial value to an area starting from an address indicated by a specific symbol immediately after unchanged data in an unchanged area; 1. A method for generating a ROMized program, comprising the step of generating a ROMized program by using data in an unchanged area including the contents as output from a linker.