JP3596570B2 - Method of allocating classes to main storage - Google Patents

Description

[0001]
TECHNICAL FIELD OF THE INVENTION
The present invention relates to a method of allocating a class of a program developed by the object-oriented technology to a main storage device.
[0002]
[Prior art]
When a program is created by object-oriented programming, for example, in the well-known C language, a class definition is performed to extract and declare the properties of an object. Within this class, you can include variables that reference the address of a variable. Among these variables are static variables, which are variables that can be referenced by all instances created from the class. The address of this static variable is expressed as an absolute address based on the top address of the class. Therefore, when compiling / linking a class and arranging it on the main storage device, an absolute address is assigned to a static variable.
[0003]
[Problems to be solved by the invention]
By the way, the above-mentioned conventional method of arranging a class in a main storage device has the following problems to be solved.
In a system developed by the object-oriented programming technology, when a program is modified or a function is added, a mechanism for dynamically allocating a new class to an empty area in a memory without stopping the system is required. In order to respond to this demand, a method using a program counter relative addressing is known. In this method, when compiling / linking, the address referred inside the class is converted into a relative address using the value of the program counter as an offset value, and is referred to at the time of execution. Therefore, the class can be relocated to an arbitrary location on the main storage device.
[0004]
However, when the class includes the above static variable, the correction is not performed up to the address of another static variable referred to by the static variable. Therefore, the address is actually incorrect and cannot be referenced. For this reason, conventionally, when the program counter relative addressing method is adopted, programming is performed while avoiding reference by static variables. However, in this case, for example, tree-structured data that refers to an address cannot be statically created. Note that the tree-structured data refers to a data structure in which variables are sequentially traced from the branches toward the trunk, and the target data is referred to.
[0005]
On the other hand, a class may include a mechanism for selecting and branching some methods included in the class. In this case, it is preferable to provide a branch function with a conditional statement or the like as performed in a general program. However, when the number of branching methods increases, the number of procedures for selecting a method and branching increases, resulting in a decrease in efficiency and a disadvantage that the code size of the class definition increases. Therefore, it is more efficient to call a corresponding method using a jump table that refers to the address of the method. However, when the above-described program counter relative addressing is used, the address of the method in the jump table is not to be corrected when the class is rearranged. Therefore, the method indicated by the absolute address cannot be called. For this reason, conventionally, such a jump table cannot be statically created.
[0006]
[Means for Solving the Problems]
The present invention employs the following configuration to solve the above points.
<Configuration 1>
A method of compiling a class definition described by the source code into an executable format file, place the correction to executable file addresses listed in the class definition in the main memory, in the class definition, the class Extract the static variables to be referenced by specifying the absolute addresses of other static variables in the definition, place the executable file in any area on the main storage device, and extract the absolute addresses of the extracted static variables , An offset address determined by the start address of the class is corrected to be added to the absolute address.
[0007]
<Description>
In the program counter relative addressing method, an absolute address on a memory, that is, a main memory is assigned to a static variable included in a class definition at the time of compiling and linking. In the object-oriented program, a static variable can be commonly referred to by all instances generated from a certain class, and cannot be changed in real memory if it is located in a data segment specified by an absolute address. Variables.
When an executable file that compiles such a class is relocated to an arbitrary free area on the main storage device, one static variable specifies and refers to the absolute address of another static variable. In such a case, the address referred to becomes invalid.
Therefore, at the time of compiling, a corresponding static variable is extracted in advance.
[0008]
If the offset address determined by the head address of the class on the main storage device is replaced with a new absolute address by correcting the absolute address, the static variable after the relocation can be referenced by the new absolute address. become. The correction may be performed immediately after compiling or after relocation to the main storage device.
This allows individual classes to be freely relocated on the main storage device. In addition, since it is only necessary to use static address references in a class, programming that is more efficient than when referencing with dynamic address translation is performed when static variables are frequently referenced. Becomes possible.
[0009]
<Configuration 2>
A method of compiling a class definition described by the source code into an executable format file, place the correction to executable file addresses listed in the class definition in the main memory, in the class definition, the class If a jump table is provided to refer to the address of the method in the definition, the absolute address of the method included in the jump table is extracted, and the executable file is placed in an arbitrary area on the memory and extracted. The absolute address of the method is corrected by adding an offset address determined by the head address of the class to the absolute address.
[0010]
<Description>
When a jump table is provided in a class to refer to the address of a method, when the class is relocated to an arbitrary area in the memory, the absolute address in the jump table does not change. Therefore, when jumping by specifying an absolute address of a certain method, the jump destination address becomes invalid. Therefore, the absolute address is corrected in the same manner as in the case of the static variable. As a result, in this case as well, since it is sufficient to employ static addressing using a jump table, more efficient programming can be performed than in the case of performing specification involving dynamic address translation by conditional branching or other operations. It becomes possible.
[0011]
BEST MODE FOR CARRYING OUT THE INVENTION
Hereinafter, embodiments of the present invention will be described using specific examples.
<Specific example 1>
FIG. 1 is a block diagram illustrating a method according to a first embodiment of the present invention.
In this method, when compiling the class definition 1, the compiler / linker 2 and the address correction information generation device 4 are used. The class definition 1 has well-known contents described by the object-oriented programming technology. The compiler / linker 2 is composed of a well-known device for compiling the class definition 1 created with the source code and generating the executable file 3. On the other hand, the address correction information generation device 4 includes a syntax analysis device 5, a semantic analysis device 6, a correction address extraction device 7, and syntax analysis tree information 8, and extracts the absolute address of a static variable from the class definition 1. Extract static variables that are specified and referenced. The syntax analyzer 5 is a part that detects elements of each sentence of the class definition 1 and analyzes its syntax, and the semantic analyzer 6 is a part that analyzes the meaning of each element. The correction address extraction device 7 uses the parse tree information 8 obtained as a result of the syntax analysis to extract a static variable to be specified by referring to the absolute address of another static variable included therein. is there. As will be described later in detail, address correction information 9 is obtained by the correction address extracting device 7. The executable format file 3 is arranged in an arbitrary position of the main storage device 13 by the arrangement device 11. At this time, while referring to the address correction information 9, the address correction device 12 extracts an absolute address portion referring to the above-described static variable in the executable format file 3 arranged in the main storage device 13, and Is corrected. The class arrangement device 10 includes such an arrangement device 11 and an address correction device 12.
[0012]
The parsing device 5 converts the contents of the address code into parse tree information 8 so as not to be parsed, and checks syntax errors and the like. This part checks for semantic errors based on the tree. The correction address extracting device 7 extracts the static variable and the absolute address of the static variable referring to the address of the static variable based on the parse tree, and stores the extracted information in a file format as address correction information in a table format. This is the part to output.
[0013]
Further, the placement device 11 of the class placement device 10 is a device for placing an executable module on a memory by a program counter relative addressing method. At this time, as described above, the contents of the static variable referring to the static variable are allocated without modification to the main storage device. The address correction device 12 detects the corresponding static variable portion of the class allocated on the main storage device by the allocation device, and uses the address correction information 9 and the start address (offset) of the class on the main storage device. This is a device that corrects the corresponding part.
[0014]
Before describing these specific operations, the PC relative addressing method, the contents of address correction information, the outline of the address correction operation, and the like will be described.
FIG. 2 is an explanatory diagram of the PC relative addressing method.
In the phase 1 shown in the figure, a class A source file is displayed. It is assumed that the source file includes, for example, a static variable a that refers to the address of the variable b. In phase 2, it is compiled and converted into an executable file. As can be seen from this figure, when the start address of the executable file is set to address 0, the variable a refers to the address of the variable b.
[0015]
Here, when the PC relative address method is adopted and the executable format file is arranged on the main storage device, the phase becomes as shown in phase 3. At this time, the start address of the class A does not always match the address 0 of the memory. Therefore, the variable a exists at the position obtained by adding the address of the variable a to the head address of the class A. Further, the variable b exists at a position obtained by adding the address of the variable b to the head address of the class A. However, the variable a is a static variable, and its contents are not changed even when it is arranged on the memory in this way, and the absolute address of the variable b is displayed as shown in phase 2. In this case, after the class is arranged on the memory in the phase 3, the variable a cannot refer to the variable b. In the present invention, an operation of converting the variable a so as to refer to the address of the variable b is performed.
[0016]
FIG. 3 is an explanatory diagram of address correction information used for this purpose.
First, the class definition 1 is converted into the executable file 15 by the compiler / linker 2 as described above. The structure of the executable file 15 in this case is the same as that shown in the phase 2 described with reference to FIG.
On the other hand, in FIG. 3, the address correction information is extracted from the class definition 1 by the address correction information generation device 4. This is performed by performing a syntax analysis or the like at the stage of the source code to extract a static variable that refers to the absolute address of the static variable. That is, the address correction information 16 is composed of the absolute address of the static variable a referring to the address of another static variable.
[0017]
FIG. 4 is an explanatory diagram of the address correction operation.
The executable format file 3 and the address correction information 9 generated as described above are input to the class arrangement device 10 shown in FIG. Then, the arrangement device 11 arranges the executable format file 3 at a predetermined location in the main storage device. At this time, the head address of the class is determined on the main storage device. The arrangement device 11 notifies this address to the address correction device 12. The address correction device 12 uses the address correction information 9 to correct the contents of the corresponding address of the class already arranged on the main storage device. That is, the value of the variable a is rewritten to be the absolute address of the head address of the class + b.
[0018]
Note that this address correction does not necessarily need to be performed after the executable format file has been placed in the main storage device. For example, if the arrangement device 11 recognizes in advance the start address at the time of allocating the class on the main storage device, it notifies the address correction device 12 and the address correction device 12 corrects the executable file 3. Do. Then, a method in which the arrangement device 11 arranges the corrected executable file 3 in the main storage device can be adopted. The former method is indicated by (1), and the latter method is indicated by (2) in FIG.
[0019]
FIG. 5 is an explanatory diagram of a specific operation of the method of the present invention.
In order to explain the method of the present invention more specifically, the contents at the time of compiling and correcting the static variables will be described in detail with reference to FIG.
First, for example, as shown in the upper left of this figure, it is assumed that the static variable included in the class definition 2 has a content of a = 100. When this is compiled in step S1, it becomes, for example, "XXXX" as shown in FIG. Here, in step S2, as described above, the address 50 of the static variable a is extracted and set as correction information. Next, the static variables compiled in step S3 are stored in the main storage device. In this case, the head address of the class is, for example, 300 as shown in FIG. Here, when the address correction processing is started, first, the contents of the absolute address referred to by the static variable a having the address 50 are corrected using the head address. That is, the top address 300 is added to the absolute address 100 that was initially referred to. Then, "YYYY" is generated by compiling a static variable referring to the correct address. Then, a correction for replacing “XXXX” of the class stored on the main storage device with “YYYY” is executed (step S5). As described above, the absolute address referred to by the static variable is corrected based on the result of class arrangement.
[0020]
<Effect of Specific Example 1>
Even when the program counter relative addressing method is employed as described above, the static variable that refers to the absolute address of another static variable is appropriately corrected, so that such a static variable can be used. . Therefore, for example, it is possible to define a static variable that refers to the address of static data that is frequently referred to only, or to adopt tree-structured data. Programming can be performed more efficiently than in the case of performing a simple address reference.
[0021]
<Specific example 2>
In the above example, the static variable existing in the class has been considered as a problem. However, a jump table that refers to the address of a method may be provided in the class. The address of the method in the jump table is an absolute address counted from the top of the class. The absolute address displayed in the jump table when converted into a file by the program counter relative addressing into an executable format file and placed on the main storage device is not converted. Therefore, the absolute address of the jump table is corrected in this specific example, similarly to the absolute address referred to by the static variable.
[0022]
FIG. 6 is a block diagram illustrating the method of the second embodiment.
The class definition 1 is compiled by the compiler / linker 2 in the same manner as in the first embodiment, and becomes an executable file 3. Further, the class definition 1 is processed by the jump table correction information generating device 20, and the jump table correction information 22 is extracted. The jump table correction information generation device 20 includes a syntax analysis device 5, a semantic analysis device 6, a jump table extraction device 21, and syntax analysis tree information 8. The jump table correction information generation device 20 analyzes the class definition 1, extracts the absolute address of the area where the address of the method on the jump table is stored, and creates the table. This table becomes the jump table correction information 22. This is very similar to the case of the first embodiment. The configurations and roles of the syntax analyzer 5 and the semantic analyzer 6 are the same as those shown in the first embodiment. The jump table extracting device 21 is a part that performs processing for extracting the absolute address of the area where the address of the method on the table is stored, based on the parse tree information 8. The class placement device 10 includes a placement device 11 and an address correction device 12 having the same configuration as described in the first embodiment. Other parts are the same as those described in the first embodiment.
[0023]
FIG. 7 is an explanatory diagram of the jump table correction information.
As shown in the figure, the class definition 1 is converted into an executable file 25 by the compiler / linker 2. At this time, for example, it is assumed that the absolute address of the method A is stored in the address a, the absolute address of the method B is stored in the address b, and the absolute address of the method C is stored in the address c. These constitute a jump table. As shown in the figure, the methods A, B, and C are stored at the corresponding addresses of the executable format file 25. The jump table correction information generating device 20 refers to the jump table and generates jump table correction information 26 as shown in FIG. The contents are the addresses a, b, and c of each part of the jump table. The method of generating such correction information is the same as in the first embodiment.
[0024]
FIG. 8 is an explanatory diagram of the address correction operation.
The executable format file 25 and the jump table correction information 26 generated as described above are used for correction processing when the file is arranged in the main storage device as shown in FIG. First, the arrangement device 11 arranges the executable format file 25 at a predetermined address on the main storage device. In this case, the address correction device 12 corrects the absolute address of the method A, the absolute address of the method B, and the absolute address of the method C specified in the jump table so that the corresponding method can be referred to. The correction in this case is performed by adding the head address of the class to each absolute address.
[0025]
The correction operation and the specific processing are the same as those described with reference to the first embodiment. Further, the address correction may be performed after the executable format file is placed on the main storage device, or the address correction may be performed in the state of the executable format file 25. This is also the same as in the first embodiment.
[0026]
<Effect of Specific Example 2>
By detecting the address jumping to a certain method in the class source code and correcting this, a jump table having the absolute address of the method can be statically created. Then, even when the classes are rearranged by the program counter relative addressing, the contents of the jump table are appropriately corrected, so that the jump table can be used in such a method. Therefore, for example, by describing the branching mechanism of a general programming language in the process of selecting and branching a method, the code size is increased, the description itself is complicated, and the programming efficiency is reduced. Can be prevented.
[Brief description of the drawings]
FIG. 1 is a block diagram illustrating a method of the present invention.
FIG. 2 is an explanatory diagram of a PC relative addressing method.
FIG. 3 is an explanatory diagram of address correction information.
FIG. 4 is an explanatory diagram of an address correction operation.
FIG. 5 is a diagram illustrating a specific operation of the method of the present invention.
FIG. 6 is a block diagram illustrating a method of a specific example 2.
FIG. 7 is an explanatory diagram of jump table correction information.
FIG. 8 is an explanatory diagram of an address correction operation.
[Explanation of symbols]
1 Class Definition 2 Compiler / Linker 3 Executable Format File 4 Address Correction Information Generator 9 Address Correction Information 10 Class Placement Device 11 Placement Device 12 Address Correction Device 13 Main Storage

Claims (2)

A method of compiling a class definition described by source code into an executable file, correcting the address indicated in the class definition, and placing the executable file in a main storage device,
In the class definition, extract a static variable to refer to by specifying an absolute address of another static variable in the class definition ,
While placing the executable file in an arbitrary area on the main storage device,
A method of allocating a class to a main storage device, wherein a correction is performed to add an offset address determined by a leading address of the class to the absolute address of the extracted static variable to the absolute address. A method of compiling a class definition described by source code into an executable file, correcting the address indicated in the class definition, and placing the executable file in a main storage device,
In the class definition, when a jump table is provided to refer to an absolute address of a method in the class definition, extracting an absolute address of a method included in the jumbe table,
Placing the executable file in any area on the memory,
A method of allocating a class to a main storage device, wherein a correction is performed by adding an offset address determined by a leading address of the class to the extracted absolute address of the method, to the absolute address.

Images