JP2011123719A - Language processing system, language processing method and language-processing program - Google Patents

Abstract

An object of the present invention is to reduce the code size of an object by minimizing the code set in a segment register.
An object code is generated in the first compilation as in a conventional compiler. In this case, a code for setting a value in the segment register is generated. The linker that has received this code outputs the information “to which segment number the variable is assigned” (this set of information is referred to as “segment information”), and uses that information to compile again. Since the segment number of the variable is known from the segment information at the second and subsequent compilations, it can be determined whether the segment register needs to be rewritten. If it is known that rewriting of the segment register is unnecessary, the setting code of the segment register can be reduced.
[Selection] Figure 4

Description

  The present invention relates to a language processing program having source input means, syntax analysis means, and object code generation means.

  A 16-bit microprocessor usually has a 64-kilobyte address space that can be expressed in 16 bits. In the market in recent years, an increasing number of cases require memory exceeding 64 kilobytes. However, 24-bit microprocessors and 32-bit microprocessors that can handle an address space exceeding 64 kilobytes are expensive, and there is a demand for a processor that can access memory exceeding 64 kilobytes with an inexpensive 16-bit microprocessor.

  In response to the needs (requests) of this market, there is a segment address type microprocessor as a method for making an address space exceeding 64 kilobytes accessible by a 16-bit microprocessor. The segment address 16-bit microprocessor includes a segment register that stores an upper address including bits higher than 16 bits, thereby handling an address space exceeding 64 kilobytes while the data bit width is 16 bits. be able to. In other words, it can be considered that segment registers divide the address space into 64 kilobytes and manage them with numbers. Hereinafter, an upper address obtained by dividing an address by 16 bits is referred to as a “segment number”.

  In the segment address method, when accessing data that does not fit in 64 kilobytes, the data is accessed after setting the segment number of the data in the segment register. For this reason, there is a problem that the size of the object code increases in the object code generation.

  As a related technique, Patent Document 1 (Japanese Patent Laid-Open No. 06-337791) describes a segment address system. Japanese Patent Laid-Open No. 07-121380 discloses that an unnecessary segment register setting code is omitted as a code reduction technique. However, it does not describe how to obtain the set value of the segment register that is a criterion for determining whether the setting of the segment register can be omitted.

  FIG. 1 shows a compilation method (language processing method) for generating a load module file 2 which is a final output from a source program file 1 described by a user. The load module file means an object code in which the memory arrangement of all data such as functions and variables is fixed.

<Conventional configuration>
As shown in FIG. 1, the conventional compilation method includes a compiler 10 and a linker 20.

  The compiler 10 includes a syntax analysis unit 11, a code generation unit 13, and an object output unit 14.

  The syntax analysis unit 11 parses the source code of the programming language described in the source program file 1. Generally, lexical analysis (lexer) is performed before syntax analysis (parser). The description of lexical analysis is omitted. For example, the syntax analysis unit 11 at the stage after cutting out a token (an instruction word or a literal) in the program of the source program file 1 by lexical analysis, based on the attribute of the token and the syntax rule described in the grammar, Derive a syntax tree.

  The code generation unit 13 generates an object code from the syntax tree.

  The object output unit 14 outputs the object code from the compiler 10 and inputs it to the linker 20. Data passed from the compiler 10 to the linker 20 is an object code whose memory arrangement has not been determined. The data delivery method may be delivery via an external file or delivery in memory.

  The linker 20 has a function of generating an executable file by adding a necessary library or the like to the object code and outputting it as a load module file 2. The load module file 2 is an executable file format module that can be loaded into the main memory.

<Conventional data access processing>
With reference to FIG. 2, the processing inside the code generation unit 13 of FIG. 1 will be described.

  Here, “data” means a variable in the source code and an area of the variable in the processor. Variables are statically allocated on the microprocessor's memory (ROM, RAM, etc.), or automatically allocated as needed in the RAM stack area, such as automatic variables in the source code. There is. “Data access” means that the microprocessor performs Read / Write (read / write) on the variable.

  “Far data” means data that does not fit in the conventional 64-kilobyte address space. Also, data that fits in the conventional 64-kilobyte address space is called “near data” to be distinguished. The user decides whether individual data is to be near data or far data. Note that it is generally a variable that is statically allocated to designate near data or far data.

(1) Step S101
When the data is accessed, the code generation unit 13 checks whether the data to be accessed (variable in the source program file 1) is far data. Here, if it is not far data, it is assumed to be near data. In the conventional method, the method for determining whether or not a variable is far data is determined by the syntax analysis unit 11 of the compiler 10 by attaching modifiers “_near” and “_far” to the variable in the source code. Whether the variable without the qualifier is to be near data or far data is determined by the compiler 10 instructing optimization, so that the parsing unit 11 of the compiler 10 processes all the near data or all the far data. Process as. The modifiers “_near” and “_far” are for convenience and are not actually limited to this example.

(2) Step S102
If it is not far data (near data), the code generation unit 13 does not need a segment register setting code. For example, since the near data fits in the conventional 64-kilobyte address space, the code generation unit 13 accesses the data without setting the segment number in the segment register and generates an object code.

(3) Step S103
The code generation unit 13 outputs a segment register setting code when it is far data. For example, since the far data does not fit in an address space of 64 kilobytes, the code generation unit 13 sets the upper address including bits higher than 16 bits as the segment number in the segment register and then accesses the data. Is generated.

  FIG. 3 shows an example of a source program file written by the user and generated object code (compiler output).

  In FIG. 3, the source program file (101) is written in C language. “_Far” is a qualifier that means far data. “_Near” is a qualifier that means near data.

  In the object code of FIG. 3, the character string starting with “;” is a source program written by the user as a comment, and is not related to the operation of the processor. “Mov” is an instruction to transfer data, and means to set data from what is written on the right side to what is written on the left side separated by commas. DS means a segment register. “#” Means a constant, and “# 1” means a constant 1. “High_addr (a)” means the upper address of the variable a, but this value is not fixed at the time of code generation, but is determined when the memory is allocated to the variable by the linker. . “! _” Means the contents of a variable. “DS:” means that an upper address set in the segment register is added to access an address space exceeding 64 kilobytes.

  Comparing the source program with the object code based on the above, when 1 is set to the variable a which is far data, the upper address of the variable a is first set to the segment register, and then 1 is set to the variable a again. Will generate code.

  At this time, the compiler analyzes the source program written by the user to generate an object code, but it is the linker that finally decides “where in the memory to place data”. That is, when the compiler generates the object code, the segment number value is not known when accessing the far data.

  For example, in the source program of FIG. 3, the variable b of the far data is accessed after the variable a of the far data is accessed. When the segment numbers of the variable a and the variable b are exactly the same, it is not necessary to reset the segment register value. However, when the compiler generates code, it cannot be determined whether or not the segment numbers of the variables a and b are finally the same. Therefore, the compiler needs to generate code that sets a value in the segment register each time.

  If the setting code to the segment register can be minimized, it is considered that the size of the object code can be reduced.

Japanese Patent Laid-Open No. 06-337791 Japanese Patent Laid-Open No. 07-121380

  An object of the present invention is to minimize the size of code generated by the compiler to set a value in the segment register each time.

  In the present invention, the object code is generated in the first compilation in the same manner as the conventional compiler. In this case, a code for setting a value in the segment register is generated. The linker that has received this code outputs the information “to which segment number the variable is assigned” (hereinafter, this collection of information is called “segment information”) and recompiles using this information. At the time of the second and subsequent compilations, since the segment number of the variable is known from the segment information, it can be determined whether the segment register needs to be rewritten. It turns out that it is not necessary to rewrite the segment register.

  The language processing system of the present invention includes a compiler and a linker. The compiler reads the source program file and generates object code based on the source program file. The linker reads the object code, and generates a load module file in which the memory allocation of the function and variable is determined based on the object code, and segment information that is a collection of information indicating which segment number the variable is assigned to To do. The compiler further includes a segment information setting unit that reads segment information, and a code generation unit that generates an object code for setting a value in the segment register when the segment information does not exist.

  In the language processing method of the present invention, a source program file is read by a compiler, and object code is generated based on the source program file. In addition, the object code is read by the linker, and the load module file in which the memory allocation of the function and the variable is determined based on the object code, and the segment information which is a collection of information indicating which segment number the variable is assigned to, And segment information is read by the compiler. If segment information does not exist, the compiler generates object code for setting a value in the segment register.

  The language processing program of the present invention reads a source program file as a compiler, generates an object code based on the source program file, reads an object code as a linker, and functions and variables based on the object code. Generating a load module file with a fixed memory allocation and segment information that is a collection of information indicating which segment number a variable is assigned to, as a compiler, reading segment information, and segment information When the program does not exist, the program causes the computer to execute a step of generating an object code for setting a value in the segment register as a compiler. The language processing program of the present invention can be stored in a storage device or a storage medium.

  The size of the object code can be reduced by reducing the setting code of the segment register.

It is a block diagram which shows the structural example of the conventional compilation system. It is a flowchart of the data access process of the conventional compilation system. They are C language for performing data access processing and assembler output in the conventional compilation method. It is a block diagram which shows the structural example of the language processing system of this invention. It is a flowchart of the data access process of the language processing system of this invention. It is C language and assembler output which perform a data access process in the language processing system of this invention.

<Basic configuration>
Embodiments of the present invention will be described below with reference to the accompanying drawings.
As shown in FIG. 4, the language processing system of the present invention includes a compiler 10 and a linker 20.

  The compiler 10 includes a syntax analysis unit 11, a segment information setting unit 12, a code generation unit 13, and an object output unit 14.

  The syntax analysis unit 11 parses the source code of the programming language described in the source program file 1. Generally, lexical analysis (lexer) is performed before syntax analysis (parser). The description of lexical analysis is omitted. For example, the syntax analysis unit 11 at the stage after cutting out a token (an instruction word or a literal) in the program of the source program file 1 by lexical analysis, based on the attribute of the token and the syntax rule described in the grammar, Derive a syntax tree.

  The segment information setting unit 12 reads the segment information 3. The segment information 3 is a collection of information indicating “to which segment number the variable is assigned”. The segment information 3 has symbol information (variable name) of each variable and information indicating whether it is near data or far data (near / far). If it is far data, it holds a segment number as information. Here, the segment information setting unit 12 receives segment information from the linker 20. The segment information 3 may be transferred via an external file or within a memory.

  The code generation unit 13 generates an object code from the syntax tree.

  The object output unit 14 outputs the object code from the compiler 10 and inputs it to the linker 20. Data passed from the compiler 10 to the linker 20 is an object code whose memory arrangement has not been determined. The data delivery method may be delivery via an external file or delivery in memory.

  The linker 20 has a function of outputting the load module file 2 and the segment information 3. Here, the linker 20 provides the segment information 3 to the segment information setting unit 12.

  As an example of the language processing system of the present invention, a computer such as a PC (personal computer), a thin client terminal / server, a workstation, a mainframe, a supercomputer is assumed. The compiler 10 and the linker 20 are not limited to the same computer, and may exist on different computers. However, actually, it is not limited to these examples.

  The syntax analysis unit 11, the segment information setting unit 12, the code generation unit 13, and the object output unit 14 are hardware such as a processing device driven by a program, and a program that drives the hardware to execute a desired process And a storage device for storing the software and various data. As an example of the processing apparatus, a CPU (Central Processing Unit), a microprocessor (microprocessor), a microcontroller, or a semiconductor integrated circuit (Integrated Circuit (IC)) having a similar function can be considered. Examples of the storage device include a RAM (Random Access Memory), a ROM (Read Only Memory), an EEPROM (Electrically Erasable and Programmable Read Only Memory), a flash memory, and other semiconductor storage devices such as an HDD (SD) An auxiliary storage device such as State Drive) or a storage medium (media) such as a DVD (Digital Versatile Disk) or a memory card is conceivable. The object output unit 14 includes a network interface when it is necessary to communicate via a network. Examples of the network interface include a network adapter such as NIC (Network Interface Card), a communication device such as an antenna, a communication port such as a connection port (connector), and the like. Examples of the network include the Internet, a LAN (Local Area Network), a wireless LAN (Wireless LAN), a WAN (Wide Area Network), a backbone (Backbone), a cable television (CATV) line, a fixed telephone network, a mobile phone network, WiMAX (IEEE 802.16a), 3G (3rd Generation), dedicated line (lease line), IrDA (Infrared Data Association), Bluetooth (registered trademark), serial communication line, data bus, and the like can be considered. However, actually, it is not limited to these examples.

<Data access processing>
With reference to FIG. 5, the processing inside the code generation unit 13 of FIG. 4 will be described.

(1) Step S201
When the data is accessed, the code generation unit 13 checks whether the data to be accessed (variable in the source program file 1) is far data. Here, if it is not far data, it is assumed to be near data. In the present invention, the segment information setting unit 12 determines whether or not the variable is far data based on the segment information 3 in FIG. In this case, the segment information 3 conflicts with the variable area location designation by the modifiers “_near” and “_far” in the source code. The segment information setting unit 12 may prioritize the segment information 3 or may prioritize modifiers such as “_near” or “_far”. If the segment information 3 is prioritized, the code size is reduced. When the modifiers “_near” and “_far” are given priority, the intention of the user is reflected.

(2) Step S202
If it is not far data (near data), the code generation unit 13 does not need a segment register setting code. For example, the code generation unit 13 accesses data without setting a segment number in the segment register, and generates an object code.

(3) Step S203
In the case of far data, the code generation unit 13 compares the value of the segment register with the segment number of the variable.

(4) Step S204
The code generation unit 13 determines whether or not the value of the segment register has been changed.

(5) Step S205
The code generation unit 13 outputs a segment register setting code when the value of the segment register is changed or when determination is impossible. For example, the code generation unit 13 sets the segment number in the segment register, accesses the data, and generates an object code.

(6) Step S206
If the value of the segment register is not changed, the code generation unit 13 does not need the segment register setting code. For example, the code generation unit 13 accesses data without setting a segment number in the segment register, and generates an object code.

  FIG. 6 shows object code obtained by inputting the same source program as FIG. 3 into the language processing system of the present invention.

<Overall operation>
[First compilation]
In the first compilation, the compiler 10 generates an object code as in the conventional case. At this time, since the segment information 3 has not been created yet, the segment information setting unit 12 does nothing. The code generation unit 13 determines whether the data is far data at the time of data access. If the data is far data, the previous segment is compared with the variable segment. Generate object code to set a value in a register. Here, in the case of far data, the code generation unit 13 checks the presence or absence of the segment information by trying to refer to the segment information. If the segment information exists, the code generation unit 13 compares the immediately preceding segment with the variable segment. If the segment information does not exist, an object code for setting a value in the segment register as indeterminable is generated. However, actually, it is not limited to this example.

[Segment information output]
The linker 20 determines the memory allocation based on the object code generated by the compiler 10. At this time, since the address of each variable is fixed, the linker 20 outputs the segment information 3.

[The second and subsequent compilations]
The compiler 10 performs the second and subsequent compilations using the segment information 3. The segment information setting unit 12 reads the segment information and has the variable segment number as information inside the compiler 10. When generating a code for accessing far data, the code generation unit 13 compares the value of the segment register with the segment number of the variable. Here, as in the first compilation, the code generation unit 13 determines whether the data is far data. In the case of far data, the code generation unit 13 checks the presence or absence of the segment information by attempting to refer to the segment information. If the information exists, the previous segment is compared with the variable segment. If the compared two values (segment register value and variable segment number) are the same, the code generation unit 13 does not generate an object code for setting the segment register. In FIG. 6, since the segment numbers of the variables a, b, and c in the segment information 3 are the same, the code generation unit 13 sets an object code that sets a value in the segment register when accessing the variables b and c. Is not output.

  Note that, here, a case where the first compile and the second and subsequent compiles are performed on the same computer has been described, but the present invention is not limited to this example. For example, when compiling the same source program file on a plurality of computers, the first compilation is regarded as the first compilation, and the segment information generated by the linker at this time is shared by the plurality of computers. By doing so, compilation on another computer can be regarded as the second and subsequent compilations. When compiling multiple times on a plurality of computers, all can be regarded as the second and subsequent compilations other than the first compilation on the first computer.

  When accessing the far data, if the value of the segment register is the same as the segment number to be set in the segment register, there is no need to generate a code for setting the segment register. However, in the conventional technique, since the memory arrangement of variables is not fixed at the time of compilation, it cannot be determined whether “the value of the segment register and the segment number to be set in the segment register are the same”. Therefore, even when the segment register setting code is unnecessary, the setting code is output.

  In the present invention, since the segment number of the variable is known by recompiling using the segment information generated by the linker, unnecessary segment register setting codes can be reduced.

  Specifically, the object code is generated in the first compilation in the same manner as in the conventional compiler. In this case, a code for setting a value in the segment register is generated. The linker that receives this code outputs the information “to which segment number the variable is assigned”, and recompiles using that information. This collection of information is called “segment information”. At the time of the second and subsequent compilations, since the segment number of the variable is known from the segment information, it can be determined whether the segment register needs to be rewritten. If it is known that rewriting of the segment register is unnecessary, the setting code of the segment register can be reduced.

  As mentioned above, although embodiment of this invention was explained in full detail, actually, it is not restricted to said embodiment, Even if there is a change of the range which does not deviate from the summary of this invention, it is included in this invention.

1 ... Source program file 2 ... Load module file 3 ... Segment information 10 ... Compiler
DESCRIPTION OF SYMBOLS 11 ... Syntax analysis part 12 ... Segment information setting part 13 ... Code generation part 14 ... Object output part 20 ... Linker (linker)

Claims (15)

A compiler that reads a source program file and generates object code based on the source program file;
The object code is read, and based on the object code, a load module file in which the memory allocation of functions and variables is determined and segment information that is a collection of information indicating which segment number the variable is assigned to are generated. Including the linker,
The compiler
A segment information setting unit for reading the segment information;
A language processing system comprising: a code generation unit that generates an object code for setting a value in a segment register when the segment information does not exist. The language processing system according to claim 1,
The segment information is
Variable symbol information,
Information indicating whether the near data fits in an address space of a predetermined size or far data that does not fit in the address space of the predetermined size;
A language processing system having a segment number if it is far data. The language processing system according to claim 2,
The code generation unit determines whether it is far data at the time of data access, and if it is far data, determines whether the value of the segment register is changed, and if the value of the segment register is changed, Alternatively, when the segment information does not exist and cannot be determined, a language processing system that generates an object code after setting a segment number in the segment register. The language processing system according to claim 2,
The code generation unit determines whether it is far data at the time of data access, and when it is not far data, or when it is far data, when it is determined whether the value of the segment register has been changed, A language processing system that eliminates the need for an object code for setting a segment number in the segment register when the value of the segment register is not changed. The language processing system according to any one of claims 2 to 4,
When compiling for the first time by the compiler, the code generation unit determines whether it is far data at the time of data access, and in the case of far data, tries to refer to the segment information, and when the segment information does not exist, Generate an object code that sets a value in the segment register as being undecidable,
The linker determines a memory arrangement based on the object code generated by the code generation unit, and after determining the address of each variable, generates the segment information,
When compiling for the second and subsequent times by the compiler, the segment information setting unit reads the segment information, holds the segment number of the variable as information inside the compiler,
The code generation unit determines whether or not the data is far data at the time of data access. If the data is far data, the code generation unit attempts to refer to the segment information. If the segment register value and the variable segment number are the same, the object code for setting the segment register is not generated and the segment register value and the variable segment number must be the same. For example, a language processing system for generating an object code for setting the segment register. Reading a source program file with a compiler and generating object code based on the source program file;
The object code is read by the linker, and the load module file in which the memory locations of the functions and variables are determined based on the object code, and segment information that is a collection of information indicating which segment number the variable is assigned to, Generating
Reading the segment information by the compiler;
A language processing method comprising: generating object code for setting a value in a segment register by the compiler when the segment information does not exist. The language processing method according to claim 6,
The segment information is
Variable symbol information,
Information indicating whether the near data fits in an address space of a predetermined size or far data that does not fit in the address space of the predetermined size;
A language processing method having a segment number for far data. The language processing method according to claim 7,
Determining whether it is far data at the time of data access by the compiler;
if it is far data, determining whether the value of the segment register has been changed;
A language processing method further comprising: generating an object code after setting a segment number in the segment register when the value of the segment register is changed or when the segment information does not exist and determination is impossible. The language processing method according to claim 7,
Determining whether it is far data at the time of data access by the compiler;
If it is not far data, or even if it is far data, when it is determined whether the value of the segment register has been changed, if the value of the segment register has not been changed, the segment number is set in the segment register A language processing method, further comprising eliminating the need for an object code to be executed. A language processing method according to any one of claims 7 to 9, wherein
When compiling for the first time by the compiler, it is determined whether or not the data is far data at the time of data access. If the data is far data, the segment information is tried to be referred to. Generating object code to set the value to
The linker determines the memory allocation based on the object code generated by the compiler, and after the address of each variable is determined, generates the segment information;
Reading the segment information at the time of the second and subsequent compilations by the compiler, and holding the segment number of the variable as information inside the compiler;
When the data is accessed, the compiler determines whether the data is far data. If the data is far data, the compiler tries to refer to the segment information. If the segment information exists, the value of the segment register and the segment number of the variable are obtained. In comparison, if the value of the segment register and the segment number of the variable are the same, the object code for setting the segment register is not generated, and if the value of the segment register and the segment number of the variable are not the same, Generating an object code for setting the segment register. As a compiler, reading a source program file and generating object code based on the source program file;
As a linker, the object code is read, a load module file in which memory allocation of functions and variables is determined based on the object code, and segment information which is a collection of information indicating which segment number a variable is assigned to A step of generating
Reading the segment information as the compiler;
When the segment information does not exist, a language processing program for causing a computer to execute an object code for setting a value in a segment register as the compiler. The language processing program according to claim 11,
The segment information is
Variable symbol information,
Information indicating whether the near data fits in an address space of a predetermined size or far data that does not fit in the address space of the predetermined size;
A language processing program having a segment number if it is far data. The language processing program according to claim 12,
As the compiler, determining whether it is far data at the time of data access;
if it is far data, determining whether the value of the segment register has been changed;
When the value of the segment register is changed, or when the segment information does not exist and cannot be determined, a segment number is set in the segment register and then an object code is generated and a computer is further executed. Language processing program. The language processing program according to claim 12,
As the compiler, determining whether it is far data at the time of data access;
If it is not far data, or even if it is far data, when it is determined whether the value of the segment register has been changed, if the value of the segment register has not been changed, the segment number is set in the segment register A language processing program for causing a computer to further execute a step that does not require an object code to be executed. The language processing program according to any one of claims 12 to 14,
When compiling for the first time implemented as the compiler, it is determined whether or not it is far data at the time of data access. In the case of far data, an attempt is made to refer to the segment information, and if the segment information does not exist, the determination is impossible. Generating object code for setting a value in the segment register;
Determining the memory allocation based on the object code generated by the compiler as the linker, and generating the segment information after the address of each variable is determined;
Reading the segment information during the second and subsequent compilations performed as the compiler, and holding the segment number of the variable as information inside the compiler;
The compiler determines whether it is far data at the time of data access. If it is far data, it tries to refer to the segment information. If the segment information exists, the value of the segment register and the segment number of the variable are obtained. In comparison, if the value of the segment register and the segment number of the variable are the same, the object code for setting the segment register is not generated, and if the value of the segment register and the segment number of the variable are not the same, A language processing program for causing a computer to further execute an object code setting step for setting the segment register.

Images