JPH0659903A - Relocatable assembling system - Google Patents

Abstract

PURPOSE:To improve a processing speed by changing allocation especially in a solving method for the reference of positional information of another machine word in a source program for a computer in the transfer of information between an assembler and a linker in a relocatable assembling system. CONSTITUTION:The system has an assembler body 110 for forming a final machine word 130 and outputting the formed machine word 130 to an object module only when a sentence for referring the positional information of another machine word appears in a source program 100 and the value of the positional information referred prior to the appearance of the sentence has been settled, and when the value is not settled yet, outputting an unsettled machine word having a margin capable of filling an unfixed part thereafter and correcting information 140 for the position of the unsettled machine word and a linker body 160 for inputting plural object modules and solving mutual reference relation in each object module prior to the solution of mutual reference relation among programs and the processing speed is improved by completing processing in the body 110 only by once.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a relocatable assemble system, and more particularly to passing information between an assembler and a linker of the system.

[0002]

2. Description of the Related Art Currently, as a program development method using a machine language grammar of a machine language, in order to improve the easiness of development, in a machine language instruction of a computer, reading and writing to a specific position in a memory and a program When writing a machine language to change the execution position, give a name (hereinafter referred to as a symbol) instead of indicating the actual position with a specific numerical value, and divide one program into multiple files. A relocatable assemble system that promotes design efficiency by describing functions by dividing them and describing standard processing functions as parts and using them many times has become common.

A conventional relocatable assemble system for realizing this function is a assembler that includes an undetermined machine language body from a source program, correction information for determining an undetermined machine language, a symbol, and an actual position. And the corresponding table (hereinafter referred to as the symbol table) are output to the object module. In the linker, multiple object modules are input and the undefined machine language is loaded by referring to the mutual symbol table and modification information. It was completed as a module.

FIG. 4 is a flow chart showing the basic form of a conventional relocatable assemble system. The assembler body 110 is composed of a pass 1 process 121 and a pass 2 process 122. Source program 1 in pass 1 processing 121
While reading 00, the contents are analyzed and a correspondence table between the symbols appearing in the source program and their actual positions is created. Next, in the pass 2 processing 122, the same source program 100 is read again and the machine language body 131 is output as an object module while referring to the above correspondence table.

The reason why the assembler body 110 rereads the source program 100 twice in this way is that the reference of the symbol in the source program 100 may appear earlier than the definition of the symbol. Furthermore, since a general relocatable assemble system has a function to create one program by dividing it into multiple files, the correspondence between symbols that may be referenced from within another source program and their actual positions. Symbol as table
On the contrary to the table 151, if the source program currently being assembled refers to another source program, the assembler body cannot determine the actual position of the symbol, so the machine language body is sent to the linker, which is the next process. Thirteen
Modification information 14 that describes where the machine language in 1 is not yet determined and what symbol is referred to
1 is output.

In this example, the machine language body 131, the modification information 141, and the symbol table 151 are collectively referred to as an object module for description.

Further, the linker main body 160 inputs a plurality of objects created by the above procedure, combines machine words to resolve cross references between machine words, and outputs the result as a load module 210. To do. The operation of the process is shown below.

The linker main body 160 executes the reading process 171 of the first object, and then executes the reading process 172 of the next object with respect to other objects designated in advance. The inter-object cross-reference resolution processing 191 is executed to resolve the cross-reference with and the series of processing is repeated for all the objects. The process completion determination 200 is a determination process for controlling that the process is repeated for all objects.

[0009]

In the above-described conventional relocatable assembler system, since it is necessary to read the source program twice by the assembler body as described above, it takes a long time to read the file. Since the parsing process is performed every time it is read, there is a drawback that the processing time is duplicated and the processing speed is slow.

The object of the present invention is to eliminate these drawbacks.
An object of the present invention is to provide a relocatable assembler system in which processing speed is improved by eliminating processing time duplication.

[0011]

According to the present invention, an assembler that inputs a source program of a computer described in a specific grammar to generate an object module and a plurality of the object modules that are read in between the programs. In a relocatable assemble system configured by a linker that resolves the cross-reference relations of the above to generate a load module of a machine language that can be finally executed, the position information of other machine languages is stored in the source program. The final machine language is generated and output to the object module only when the referenced sentence appears and the value of the position information referenced before the sentence appears is fixed, and the position information value is fixed. If not, the undefined machine language that leaves room to embed the indefinite part and the correction information for the position are stored in the object module. And a linker for resolving the cross-reference relationship in the object module in units of one object module before inputting a plurality of the object modules and resolving the cross-reference relationship between programs. Is characterized by.

[0012]

1 is a flow chart of the basic form of a relocatable assemble system according to an embodiment of the present invention. In the figure, in the present embodiment, the structure of the assembler body 110 is realized only by the path 1 processing 111, and the linker body 160 resolves a cross reference in one object 180.
Is the major difference. The details of the operation will be described below.

In this embodiment, while reading the source program 100 in the pass 1 processing 111 of the assembler body 110, a correspondence table of the symbols that have appeared and their actual positions is created in the same manner as in the pass 1 processing 121 of the prior art. However, at the same time, the machine language main body 13
Outputs 0.

In this case, the difference from the conventional technique is that even if there is a symbol existing in the source program, if it appears earlier in the file than the statement defined by the referenced statement, another source program is used. The difference is that it is processed as an undetermined machine language like the symbol defined in. As a result, the content of the output object is similar in form to the object output by the conventional technique, but the machine language main body 130 has many undetermined parts, the correction information 140 is large, and the symbol table 150 is large. Also, the symbols defined in the one source program and not referred to in another source program are additionally output.

On the other hand, the linker main body 160 inputs a plurality of the above objects, combines the machine language and outputs the load module, and the processing flow is realized by the following method.

First, the first object is read. Since the processing is functionally similar to the reading of a general object, it is realized by the reading processing 170 for one object. Next, resolution processing 1 of the cross reference in the object
At 80, the cross-reference relation in the first object is resolved by the modification information 140 and the symbol table 150. In the case of the first object, the next processing, that is, the processing for resolving cross-references 190 between objects is not executed because there is still only one object, and the processing proceeds directly to the next determination processing 200. After that, the above processing is repeated until the designated objects are sequentially read until there are no more objects.

Here, a cross-reference resolution process 180 within one object and a cross-reference resolution process 19 between objects are performed.
The difference of 0 is only the difference of the search range, and since they are almost the same in terms of program, there is a great design advantage.
Next, one embodiment of the details of the function of each part of the present invention will be described with reference to the drawings.

FIG. 2 shows the assembler body 110 of this embodiment.
6 is a flowchart showing an example of the path 1 processing 111 in FIG. Table 1 below is an example of the contents of the source program prepared to explain the operation of FIG.

[0019]

[Table 1]

In the table, sentence 11 on the first line indicates that the symbol "L1" is defined at this position. Since a sentence for generating a machine language is not described in this sentence, the symbol "L1" automatically indicates the contents of the second line. The statement 12 on the second line is a statement in which an instruction to transfer control from here to the symbol “L1” defined on the first line is described. Sentence 13 on the third line is
This is a statement in which an instruction for transferring control to the symbol “L2” defined in the line is described. The sentence 14 in the fourth line defines the symbol "L2" as in the sentence in the first line. The statement 15 on the 5th line is a statement that describes an instruction to transfer control to the symbol "L3" that is predicted to be defined in another file, and the statement 16 on the 6th line is this position from another file. The symbol "L4" that allows the transfer of control to is defined.

Next, the case where the source program of Table 1 is input in FIG. 2 of the present embodiment will be described. In the pass 1 processing, first, the sentence 11 in the first line is read in the one-line reading process 300 of the program. The next process, which is a process 310 for determining whether the file is the last, is a process for ending the program when the pass 1 process is completed. Next, the instruction analysis processing 320 determines that this is only the definition of symbols. As a result, the symbol registration process 331 is executed in the next determination process 330, and the symbol "L1" and its position information are registered.

Next, is there a symbol reference? Judgment process 34
When it is 0, it is determined that there is no symbol reference, and control is directly transferred to the machine language generation processing 350. In this machine language generation processing 350, since there is no machine language generation description in this sentence, nothing is done, and the process moves to the one-line reading processing 300 of the program again.

Next, the sentence 12 on the second line is read. This sentence is a sentence "JUMP" for generating a machine language that transfers control to the place of the symbol "L1". This statement is analyzed in the instruction analysis processing 320 and there is no symbol definition, so processing 3
30 is not done, symbol definition? Determination process 340
Is it judged that there is a reference in and the next symbol is already registered? Since the symbol “L1” has already been registered in the determination processing 341, the position indicated by the symbol is converted into a specific numerical value in the symbol → numerical processing 342. After that, in the machine language generation processing 350, the machine language "JUMP" and the actual value of the jump destination "L1" are combined and machine language body 13
Outputs 0.

In the sentence 13 on the third line, "JU" for generating a machine language for transferring control to a symbol "L2" which has not been registered yet.
The sentence is "MP". This sentence is processed in the same way as the sentence 12 in the second line until the symbol is unregistered in the determination process 341. After that, since it is not registered, the correction information creation process 3
43 is executed, and the information that the position of the machine language on the third line is undetermined and the correction information that the position refers to the symbol “L2” are created.

In the next machine language generation processing 350, "JUM
The machine language "P" is the machine language itself 1
Output as 30.

In the sentence 14 in the fourth line, the same processing as that in the sentence 11 in the first line is performed, and the symbol "L2" is registered. The statement 15 on the fifth line is a statement "JUMP" that causes a machine language to transfer control to the symbol "L3" which is expected to be defined in another source program. The processing of this sentence is 3
The same processing as that of the sentence 13 on the line is performed, and the correction information for the unregistered symbol "L3" and the undetermined machine language body 130 are output. The sentence 16 in the sixth line is subjected to the same processing as the sentence 11 in the first line, and the symbol “L4” is registered.

After the above-mentioned pass 1 processing 111 processing, the internal correction information and the symbol correction information 140 and the symbol table 15 finally completed by the assembler body 110.
The 0 is output as a file to the outside, and the assembler process is completed.

The following Tables 2 (a) and 2 (b) show the modification information 140 and the symbol table 15 created by the above-mentioned processing.
It is a specific example showing 0 in a table format.

[0029]

[Table 2]

In Table 2 (a), the position information is a column of numerical values of specific positions of the machine language to be corrected, and the symbol is a column of the symbol itself indicating which symbol is used to correct the above-mentioned portion to be corrected. is there. In this case, the modification format is a code that predetermines information about how to modify the concrete value of the symbol to modify the machine language itself, and in the case of a general assembler, it is the information required by its grammar. . However, in the present embodiment, since it is not related, further description will not be given.

Next, the first line 21 of Table 2 (a) is a set of modified formats created by the processing of the third line of the example of the source program of Table 1, and the second line 22 is the fifth line. 4 shows a set of modified formats created by the process.

Next, in Table 2 (a), the symbol indicates the column for storing the registered concrete symbol, and the symbol value indicates the column 212 for storing the actual value indicated by the symbol. There is. Next, the first line 31 of Table 2 (a) is a line in which the position information is associated with the symbol "L1" registered by the processing of the first line of the example of the source program of Table 1, and the second line 32 Is a process of the fourth line of the example of the source program, and the third line is a line in which the symbol registered in the process of the sixth line of the example of the source program and its position information are associated with each other.

FIG. 3 is a flow chart of the linker of the second embodiment of the present invention. Again, Tables 2 (a) and (b) are examples of the modification information 140 and the symbol table 150 generated from the source program of Table 1.

The symbol name and position information in Table 2 (a) are 1
This is a structure of a set of correction information, where the symbol name stores the actual referenced symbol name itself, and the position information stores the position of the machine language that refers to the symbol name. Table 2
Row numbers 21 to 23 in (a) are the second row and the third row in Table 1, respectively.
It is the modification information of the symbol generated by the machine language instruction that refers to the symbol on the line 5 (12, 13, 15). Here, for simplification of explanation, all the instructions have the same length and the length is set to 1. In line number 21, the symbol name "L1" is referenced, and the position is the first machine language, so the position is 0, line number 2
2, the position is 1 by referring to the symbol name “L2”, and the line number 23 is 2 by referring to the symbol name “L3”.
Has become.

The symbol table in Table 2 (b) is composed of the symbol name referred to for one set of symbols and the value of the symbol, and the line numbers 31 to 33 define the symbols in Table 1, respectively. 5 is a correspondence table of symbols generated by the statements on the 1st, 4th, and 6th lines. The line number 31 defines the symbol name “L1” and its position is 03, the line number 32 defines the symbol name “L2”, and its position is 2, and the line number 33 defines the symbol name “L4”. The position of the cage is 3.

Next, the operation will be described with reference to the example of Table 2 with reference to FIG. The machine language position and symbol table initialization processing 400, which is the first processing, empties the symbol table and simultaneously initializes the position of the object to be read to 0. Next, as the reading processing 170 for one object in FIG. 1, processings 401 to 404 are performed. First, the machine language is read after the position of the machine language to be read in the reading process 401 of one machine language body. Next, in order to calculate the read position of the machine language to be read next in the machine word position addition processing 402, the size of the machine language body read at that time is added to the machine word position.

Next, the symbol table of the object is registered to be added to the already read symbol by the additional reading processing 403 of the one symbol table. This symbol table has the format shown in Table 2 (b). At this point, the value of the current machine language position is added to the value of the symbol in the symbol table and registered. Next, by the correction information 1 machine language read processing 404, the machine language correction information as shown in Table 2 (a) is read. In this case as well, the value of the machine language position is added to the position information portion and registered.

After that, the processes 405 to 407 are executed as the process 180 for resolving cross-references within one object in FIG. First, is the confirmation correction information for processing all the correction information completed? Completion is confirmed by the process 405 of
The internal processing is repeated until the processing of the read correction information is completed. Next, is the symbol of the correction information in the symbol table? The value to be corrected is obtained in the processing 406 of.
The machine language is completed by the processing 407 of modifying the machine language by the value of the symbol with the obtained value.

In the case of Table 2 (a), since the symbol names "L1" and "L2" are registered in the symbol table at that time, the position "L1" is 0 and the position "L2" is 2. . Therefore, the portion determined by the machine language symbol at position 0 is changed to a value of 0 by processing 407,
Similarly, the machine language portion at position 1 is changed to a value of 2. In case of the example in Table 2 when all the processing of the correction information is completed,
The symbol name “L3” remains undefined.

After that, processes 408 to 410 are executed as a process 190 of resolving cross-references between objects.
Is there any correction information that was not in the symbol table before?
Process 408 is a determination process for an object read immediately before that, not an object read at that time. Therefore, it is determined that there is no correction information at the time of reading the first object, and processing 1
Return to 70. Then another object is loaded. When the processing of the object is completed up to the processing 180, the processing moves to the processing 190 again.

If the symbol "L3" is defined in the object read at that time, is the symbol of the correction information in the symbol table?
The symbol name "L3" is found by the process 409 of step 409, and the machine language part at the position 2 is changed by the value registered as "L3" by the process 410 of modifying the machine language by the value of the process symbol similar to the process 407. . In this way, until reading of all specified objects is completed,
By repeating the above process, cross reference of all symbols is completed.

[0042]

As described above, according to the present invention, the processing of the assembler portion of the conventional relocatable assemble system is almost halved, and the processing of the linker is similar to the processing of the conventional linker. Therefore, there is almost no increase in the capacity of the program, and the processing time can be expected to be much less than the time required for parsing the conventional machine grammar.

[Brief description of drawings]

FIG. 1 is a flow chart of an embodiment of a relocatable assembler system of the present invention.

2 is a flow chart of an example of pass 1 processing of the assembler of the system of FIG.

3 is a flow chart of an example of a linker for the system of FIG.

FIG. 4 is a flowchart of an example of a conventional relocatable assemble system.

[Explanation of symbols]

100 Source program 110 Assembler body 111 Path 1 processing 121,122 Conventional path 1, 2 processing 130,131 Machine language body 140,141 Modification information 150,151 Symbol table 160 Linker body 170 1 Object reading processing 171 Conventional first Object read processing of 172 Conventional read processing of the next object 180 1 Cross-reference resolution within an object 190, 191 Cross-reference resolution processing between objects 200 Evaluating the existence of remaining objects 210 Load module 300 Reading one line of a program Processing 310 Program end determination processing 320 Program one line analysis processing 330 Symbol definition presence / absence determination processing 331 Symbol registration processing 340 Symbol reference presence / absence determination processing 341 Symbol Already registered judgment process 342 Symbol digitization process 343 Correction information creation process 350 Machine language generation process 400 Symbol table initialization process 401 Process of reading the machine language main part of a set of objects 402 Machine language Addition of main body size 403 Processing to read symbol table part of one set of objects 404 Processing to read correction information part of one set of objects 405 Confirm completion of processing of modification information in one set of objects Processing 406,409 Processing for determining whether or not correction information symbols are registered in the symbol table 407,410 Correction processing for a complete machine language based on the values in the symbol table 408 Processing for checking whether there are unregistered symbols in the symbol table Statement that specifies the definition of symbol "L1" 12 Control to symbol "L1" The statement that specifies the generation of the machine language for the computer that transfers the statement 13 The statement that specifies the generation of the machine language for the computer that transfers the control 14 The statement that specifies the definition of the symbol “L2” 15 Statement for specifying generation of machine language for computer to be transferred 16 Statement for specifying definition of symbol "L4" 21 to 23 Symbols "L1", "L2" and "L"
Modification information 31 to 33 generated by referring to "3" Symbols "L1", "L2" and "L"
3 ”definition information

Claims (1)

[Claims] 1. A program (hereinafter, referred to as an assembler) for generating a machine language information (hereinafter, referred to as an object module) by inputting a source program of a computer described in a specific grammar, and a plurality of the object modules are read, and the program is stored between the programs. In a relocatable assemble system composed of a program (hereinafter referred to as a linker) that resolves the cross-reference relation of and finally generates an executable machine language (hereinafter referred to as a load module),
When a statement referring to position information of another machine language appears in the source program and the value of the referenced position information is already fixed, a final machine language is generated and output to the object module, When the value of the position information is not fixed, a machine language that leaves room for embedding an indefinite part (hereinafter referred to as undetermined machine language), information indicating that the position is undetermined, and a modification form thereof Information (hereinafter referred to as correction information)
And an assembler having means for outputting the object module, and resolving the cross-reference relationship within the object module in units of one object module before resolving the cross-reference relationship between the programs by inputting a plurality of the object modules. A relocatable assemble system comprising a linker.