JP2000010792A - Global register system, method and computer program product - Google Patents

Abstract

(57) Abstract: A system, method and computer program product for compiling and linking a source file and generating a symbol table associating global symbols with registers referenced in the source file. A symbol table enables a linker to initialize a global register using a relocation entry holding an initializer. The compiler also generates an object file from the source file. The object file contains global symbol information. The linker links the object file with at least one other object file or shared library to generate an executable file or shared library. The linker uses the global symbol information included in the object file to initialize a global register and execute a relocation operation.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

FIELD OF THE INVENTION The field of the invention relates to systems, methods and computer program products for global register use and collision detection, and more particularly to global register use indicators and detection of use collisions in global registers.

[0002]

BACKGROUND OF THE INVENTION In certain computer program systems, registers are used to temporarily hold a copy of the contents of a variable required by a running computer program. The continuous value of the variable is stored in memory. Also, one or more registers in a computer program system are designed to be of global scope (ie, used by the entire computer system, rather than by a particular module or subroutine), and the global scope is also designed. It has been found useful to provide for the use of global register specific variables.

[0003]

The specific program is:
Since each is linked from a separately compiled object module, different symbols may reference the same global register, resulting in incorrect references to variables and incorrect scope. Certain programs also include one or more separately compiled libraries, exacerbating the problem of misreference. A serious technical problem comes to light when each of the different parts of a particular program uses one global register provided to store different variable values. Such use tends to produce incorrect results because the wrong variable value is in the global register at the wrong time.

[0004] In addition, another technical problem arises with respect to initializing global values during software operations. Mechanisms for initializing a variable in memory with a given value before the start of program execution are known, but a register for storing a global variable set to a given value before the start of execution The mechanism for initializing is unknown.

[0005]

SUMMARY OF THE INVENTION In accordance with the present invention, separately compiled software units use these global register usages so that static and dynamic linkers can detect usage conflicts due to compilation. Is specified. Furthermore, according to the present invention, the global register
It is initialized to a desired value before the execution of the program starts.
According to one embodiment of the present invention, the symbol table type "ST
"T_SPARC_REGISTER" is established to specify a particular symbol table entry that associates a global symbol with a particular global register. The “name” portion of the symbol table entry points to a string that stores a symbol name or a null value indicating that the register is used as scratch space. The "value" portion of a symbol table entry indicates the particular register to which this entry applies. The other part of the symbol table entry indicates whether there is an initializer for a particular register. According to another embodiment of the present invention, the relocation type "R_SPAR
“C_REGISTER” indicates the initial value of the global register.

According to the present invention, the compiler generates a symbol table entry such that the included object file indicates how to use the global registers reserved by the application. The static linker examines the generated symbol table for all object files bound to a particular target file and ensures that global registers referenced by different source elements can be shared. The generated result object file includes these symbol table entries to indicate the use of the result object global register. According to the present invention, the static linker warns if any of the shared object files referenced during linking use global registers in a manner that cannot be shared with the object file being created. According to the present invention, if a shared object file that uses a global register reserved by an application has been generated, the static linker generates a warning. If the archive library is generated using the global registers secured by the application, a similar warning is issued by the archiver according to the present invention. The dynamic linker according to the present invention allows all object files bound to the selected process to
Check to ensure that the application can share the reserved global registers.

[0007] In accordance with the present invention, a system and method for compiling and linking a source file are provided for maintaining variable class information related to global symbols referenced or defined in a particular source file. Includes a compiler for generating a symbol table that links symbols to corresponding global registers. This symbol table information is sufficient to enable the linker to analyze class definitions and perform class relocation operations. This symbol table information is included in the object file generated by the compiler. The compiler creates an object file specifically to delay the use conflict identification and relocation operations until the linker operation. The linker links object files with other object files and shared libraries, thereby generating either executable files or shared libraries. The list of other object files and shared libraries may be empty, in which case the linker generates an executable or shared library from a single object file. The linker uses the class information in the object file to identify a usage conflict and executes a relocation operation.

[0008]

FIG. 1 is a diagram of the data flow of a compilation according to a preferred embodiment of the present invention. In particular, FIG. 1 illustrates a compiler 104, a static linker 114, and a runtime linker 1 according to one embodiment of the present invention.
18 inclusive. The compiler 104 generates the source file 10
2 to generate an object file 106. Source file 102 is written in a known C, C ++, or Fortran computer programming language according to another embodiment of the present invention. It is important to note that the present invention places no restrictions on the use of the particular language that the developer has chosen to create the source file 102.
According to one embodiment of the present invention, static linker 114
Contains a rearranged code section used for register symbol initialization. Relocation code section, name = .rela, type = S
HT_RELA, and attribute = none, so the table below is valid.

[0009]

[Table 1]

.Rela: sh_link contains the section header index of the related symbol table, and sh_info contains 0
Indicates that this section only contains register relocations.

[0011] The object file 106, simultaneously zero or more other object files 108, and / or zero or more shared libraries 110 are transferred to a static linker 114 in accordance with the present invention. The other object files 108 were previously compiled by the compiler 104 of the present invention, and the shared library 110 was previously created by the static linker 114. Static linker 1
14 generates an executable file 116. According to one embodiment of the present invention, the static linker 114 generates another shared library. As will be appreciated, shared libraries are in the form of object files. Thus, the terms "object file" and "shared library" are used interchangeably herein. As those skilled in the art will appreciate, executable file 116 contains code, data, and other information from object files 106, 108, and also contains references to shared library 110 (ie, shared library 110). The code, data, etc. from are not actually incorporated into the executable file 116). At runtime, the executable 116 and the shared library 110 are transferred to the runtime linker 118. The runtime linker 118 then decomposes the references contained in the executable 116 into a shared library and creates an executable image 120. The execution image 120 is stored in the main memory 208 and executed in the central processing unit 204 (FIG. 2). In general, the operations of the static linker 114 and the runtime linker 118 are broken down into four phases, as detailed in FIGS.

FIG. 2 is a block diagram of a computer system according to a preferred embodiment of the present invention. Computer system 202 includes one or more processing devices, such as a central processing unit (CPU) 204, connected to a communication medium, such as a bus 206. A main memory (not limited to random access memory (RAM)) 208 is also connected to bus 206. Compiler 104 and linker 1
12 is stored in the main memory 208. Linker 11
2 includes a static linker 114 and a runtime or dynamic linker, or both, in accordance with the present invention. Source file 102, object files 106 and 108,
The shared library 110 and the execution image 120 are also preferably stored in the main memory 208. Computer system 202 further includes register 210. A computer program product, such as disk 214, includes a computer readable medium having computer program logic recorded thereon, which, when executed within computer system 202, causes The functions can be read by an auxiliary storage device such as a floppy disk drive 212 so that the functions can be performed. The computer program logic describing the compiler 114 and the linker 112 is then loaded into the main memory 208 (as shown) and
04. Computer system 202
A suitable format is a Sun Microsystems workstation from Sun Microsystems, Inc. of Mountain View, California. Alternatively, any other suitable computer system can be used.

FIG. 3 is a flowchart of a linker process that can be used in connection with the present invention. Flowchart 3
02, in particular, the static linker 114 and the runtime linker 1
Reference numeral 18 denotes an execution 306 of a read phase, a layout phase 308, a rearrangement phase 310, and a write phase 312 for performing a process of executing a read operation after the start phase 304. These linker phases 306, 30
8, 310 and 312 are well known to those skilled in the art. The flowchart 302 is for the end phase 31
4 is completed.

FIG. 4 is a flowchart 352 of a linker process according to one embodiment of the present invention. In particular, after completion of the start phase 354, a read phase 356 is performed, where the static linker 114 and the runtime linker 118 perform processing to perform a read operation.
Thereafter, a layout phase 358 is performed, followed by a relocation phase 360 and a write to memory phase 362. Thereafter, in accordance with the present invention, the global registers are initialized, control passes to the executable image, and is then completed in the end phase 394.

FIG. 5 is a block diagram of object file generation by a compiler according to a preferred embodiment of the present invention. As shown in FIG.
06 is code and data 402 and symbol information 40
6 inclusive. According to one embodiment of the present invention, object file 106 further includes one or other, or both, symbol table 404 and symbol table 408. The symbol information 406 according to one embodiment of the present invention includes a symbol table 408. Further, according to one embodiment of the present invention, the symbol information 406
Includes a relocation table 412. Compiler 10
4 is a symbol table 4 including codes and data 402, and global symbols and global register information.
08, and the information 406 is embedded in the object file 106. This global symbol and global register information includes data about global symbols and global registers defined and / or referenced in the source file 102, and further describes how the source file 102 uses the global symbol and global register information. Also includes additional information. The global symbol and global register information 406 generated by the compiler 104, whether it is static, dynamic or runtime,
Identifies global symbol collisions and global register collisions and performs relocation according to the present invention.

As described above, according to the present invention, it is not the compiler 104 that performs collision and relocation of global symbols. Instead, the identification of global symbol collisions is delayed from compile time to link time in accordance with the present invention. As shown in FIG. 6, according to step 506 following start phase 504, compiler 104 is used to generate information about global symbols and their usage. The above information about global symbol collisions is called into the symbol information 406 and embedded in the object file 106 created by the compiler 104. FIG. 6 is a flowchart of a compile / link process according to a preferred embodiment of the present invention. More specifically, FIG.
Depicts a flowchart 502 according to the present invention, representing the high-level processing of one of the compiler 104 and one of the linkers 114, 118. Source file 10
4 compiles step 506 and the linker 114, 11 when processing the object files 106 and 108 and the shared library 110.
An appropriate one of the eight performs step 508. Flowchart 502 begins at step 504, and after completion of this start phase, control is passed to step 506. The compiler generates information about the global symbol table entries so that the object files contained therein indicate how to use the global registers reserved by a particular application. The programmer may thus, for example, use a flag according to one embodiment of the invention to a compiler or to a assembler using flags or instructions according to another embodiment of the invention
Indicates what the specific register usage for the selected global register is. In step 506, the compiler 104 generates the object file 106 from the source file 102. In step 508, the appropriate linker 114, 118
16 and then an execution image 120 is generated from the object files 106, 108 and the shared file 110. As described above, during the generation of the executable file 116 and the executable image 120, the static linker 114 and the runtime linker 118 configure the read phase 306, layout phase 308, relocation phase 310, and
Execute Step 2. In accordance with the present invention, these linker phases 306, 308, 310, and 312 are modified so that static linker 114 and runtime linker 118 identify global symbol collisions and perform relocation.
The operation of the static linker 114 and the runtime linker 118 will be described in more detail below. After step 508 has been completely executed, the process of flowchart 502 is completed, as indicated by step 510. The static linker checks these symbol table entries in the executable file or object file associated with the shared library to make sure that the global registers are being used for sharing. In accordance with the present invention, the resulting object includes an entry in its symbol table to indicate the global register usage of the resulting object. The static linker warns when any of the shared libraries referenced during linking use global registers in a way that they do not share with the object under construction. In accordance with one embodiment of the present invention, the static linker issues a warning when further attempting to build a shared object that utilizes an application-allocated global register. When an archive library is generated including an object using the global register allocated by the application, a similar warning is issued by the archiver. The dynamic linker according to the present invention checks that all object files bound to the target process use application-allocated global registers in a shareable manner. Dlopen () on objects that are incompatible with the application process
Fails with an error, for example, according to the present invention.

[0017]

[Table 2]

* OK is used when the symbols are the same. N
O is used when they are not identical. Two symbols are identical when only one of the following is true: A. Both are global and have the same name. B. Both are local, have the same name, and are defined in the same object.

The scratch symbol according to the present invention is:
Since the null name matches only the null name and the scratch register according to the present invention has a global scope, it is treated as a symbol. For the same register symbol
The matrix of permissible combinations of st_shndx is described below.

[0020]

[Table 3]

The symbol information 406 according to one embodiment of the present invention includes (1) a symbol table 408 containing a list of global symbols, and (2) a relocation table 412 containing a list of global symbols. Using the symbol information 406, the appropriate linker 11
4 or 118 determines the exact layout of the global symbols used by the application and then implements the required relocation. The symbol table 408 includes a plurality of entries, each entry corresponding to one symbol. These entries are used by linker 1 during the relocation process.
14 and 118 use.

FIG. 7 is a detailed flowchart of the link processing according to the preferred embodiment of the present invention. The linker generally operates according to four phases: a read phase 306, a layout phase 308, a relocation phase 310, and a write phase 312 (FIG. 3).
In the present invention, these linker phases 306, 30
8, 310 and 312 have been modified so that the appropriate linker identifies global symbol collisions. This correction is shown in the flowchart 602 of FIG. Specifically, step 606 is preferably performed during read phase 306. Step 608 is preferably performed between read phase 306 and layout phase 308. According to step 610, the global symbol collision identified in steps 612 and 614 preferably includes the layout phase 308 and the rearrangement phase 31
Executed between 0. Step 616 preferably includes
Performed during the relocation phase 310. Here, the flowchart 602 will be described. Flowchart 602 begins at step 604, where control immediately proceeds to step 606.
Passed to. In step 606, the appropriate linker reads the object files 106, 108 and the shared library 110 and integrates the global symbol information 406 contained in these files. In particular, a suitable linker integrates the global symbol tables 408 contained in these files to generate an integrated symbol table. Similarly, a suitable linker is
The relocation table 412 is integrated to generate an integrated relocation table. In step 608, the appropriate linker identifies a global symbol collision. To elaborate, the appropriate linker processes the integration table to lay out each symbol (eg, the size and alignment of each symbol,
Field number, field data type, number of bytes from the top of the symbol to each of the fields, etc.). Suitable linkers create a separate data structure for each symbol and store this symbol-specific information in said data structure. These data structures are referred to as "layout data structures" for reference purposes. Upon completion of step 608, the appropriate linker knows all of the conventionally known symbol related information created by the conventional compiler. At step 612, the appropriate linker evaluates the symbols in the integrated symbol table. To elaborate,
A suitable linker determines the value of the symbol in each entry of the integrated symbol table and stores this value in the value field of the entry. For example, consider the example symbol table 408 of FIG. The appropriate linker determines the values of entries 714 and 718 with reference to the specific Krasno appropriate layout data structure. The appropriate linker stores these values in the value fields of these entries 714 and 718. The manner in which the linker 112 calculates values for other symbol types has been described above. In step 614, the appropriate linker initializes a global register structure. In particular, during step 614, the appropriate linker generates tables and table pointer information tables and stores these tables in the already allocated application data structure. In step 616, the appropriate linker performs the relocation specified in the entry of the consolidated relocation table. The manner in which a suitable linker performs this function has been described above. After step 616 has been completely executed, the process of flowchart 602 is completed, as indicated by step 618. As those skilled in the art will appreciate, the above-described operation of a suitable linker is illustratively performed collectively by the static linker 114 and the runtime linker 118.
It is not important in the present invention whether the static linker 114 or the runtime linker 118 performs the above operation. However, when the static linker 114 attempts to prelink executable and shared objects, and the executable and shared objects are in the same state as when they were created, the runtime linker 118 only loads and starts the file. It is preferable that the process be completed. In an example, the runtime linker 118 must read many relocations made by the static linker.

FIG. 8 is an example of a symbol table generated by a compiler according to a preferred embodiment of the present invention. FIG. 8 specifically illustrates the first and second symbol table entries 714 and 71 in the example symbol table 408.
8 is shown. Each entry of the symbol table 408 includes information for identifying a symbol type and information indicating a value of a symbol of this class. The entry for a particular symbol may additionally include fields such as, for example, the symbol name, symbol size, symbol combination, and symbol section index. Symbol names include member names where appropriate. The list of symbol types is
It is implementation specific and depends on many factors, such as the computer programming language and the target machine. Examples of symbol types will be apparent to those skilled in the art.

As explained below, a suitable linker is
Before processing the relocation entry in the relocation table 412, the value of the symbol in the symbol table 408 of the present invention is calculated. In processing each relocation entry, its value is read from the symbol table and stored at a given address according to the type of the relocation entry. See the example in FIG. Prior to processing the relocation entries in relocation table 412, the appropriate linker evaluates symbol entries 714, 718 in symbol table 408 and reads the value associated with each symbol entry. The appropriate linker then places the read value in the value field of symbol entry 714. According to one embodiment of the present invention, a suitable linker places this value (8 bytes) in the value field of symbol entry 718. During processing of a particular relocation entry, a suitable linker according to the present invention replaces the position holder in the instruction at the particular address with the value in the symbol entry 714. This is because the pointer in the relocation entry 714 is the symbol entry 71
4. Similarly, during the processing of a particular relocation entry for the relocation table 412, the appropriate linker will return 0 (ie, "") in the instruction at the particular address.
0 ") is replaced with the value provided in the symbol entry 714. The registered symbols in the symbol table according to one embodiment of the present invention have specific additional symbol types and Indicated by value.

[0025]

[Table 4]

A symbol table entry for a register symbol according to one embodiment of the present invention includes the following elements: st_name: Index of the symbol name into the string table. An index value of 0 pointing to a null name in the string table indicates that the register is being used for scratch. The scratch register must have the binding STB_GLOBAL. st_value: Register member. Register members are
Corresponds to the assignment in the SPARC Architecture Manual for integer registers. st_size: Not used (0) st_info: ELF64_ST_INF0 (Bind type). The binding is usually STB_GLOBAL, but reflects the scope of the actual declared name (that is, it can be STB_WEAK or STB_LOCAL). The type must be STB_REGISTER (13). st_other: Unused (0) st_shndx: SHN_ABS if this object initializes this register symbol, SHN_UNDE otherwise
F. The initializer for the SHN_ABS register symbol is specified using a special register relocation type.

A missing entry for a particular global register means that the object is not using that particular global register. Objects in accordance with the present invention use global registers reserved by one or more applications to indicate the use of this appropriate symbol table entry. According to one embodiment of the present invention, the following dynamic array tags are further added to the symbol table.

[0028]

[Table 5]

The compiler 104 according to the present invention therefore produces code that is relocated at link time. In particular,
When a variable is referenced in the source file, the compiler 104 generates both the symbol table 408 and the relocation table 412. According to one embodiment of the present invention, the generation of the symbol and relocation table identifies a special global register used to identify global register conflicts and initialize the global register prior to execution of the generated execution image. Achieved by the relocation type.

FIG. 9 is an example of a relocation table according to an embodiment of the present invention. Relocation table 412 contains a list of relocations to be performed by the appropriate linker at link time. Each entry in relocation table 412 includes the relocation type, the address of either the instruction or the data element that needs to be relocated, and a pointer to the entry in symbol table 408. The following relocation types are added to the relocation table according to the present invention.

[Table 6]

While various embodiments of the present invention have been described above, it should be understood that they have been presented by way of example only, and not limitation. Thus, the breadth and scope of the present invention should not be limited by any of the above-described embodiments, but should be defined only in accordance with the following claims and their equivalents.

[0032]

According to the present invention, prior to the start of execution of a program, a register for storing a global variable which needs to be set to a predetermined selected value is initialized.

[Brief description of the drawings]

FIG. 1 is a diagram of a compiled data flow according to a preferred embodiment of the present invention.

FIG. 2 is a block diagram of a computer system according to a preferred embodiment of the present invention.

FIG. 3 is a flowchart of a linker process used in connection with the present invention.

FIG. 4 is a flowchart of a linker process according to one embodiment of the present invention.

FIG. 5 is a block diagram of an object file generated by a compiler according to a preferred embodiment of the present invention.

FIG. 6 shows a compile / process according to a preferred embodiment of the present invention.
It is a flowchart of a link process.

FIG. 7 is a detailed flowchart of a link process according to a preferred embodiment of the present invention;

FIG. 8 is a diagram illustrating an example of a symbol table generated by a compiler according to a preferred embodiment of the present invention.

FIG. 9 is a diagram showing a relocation table according to an embodiment of the present invention.

 ────────────────────────────────────────────────── ─── Continuing on the front page (72) Inventor Rodrick Isson Evans United States 94025 Menlo Park, Arboa Road, California 252 (72) Inventor Michael S. Walker United States 94022 Los Altos, Los Angeles Los Angeles 638 California

Claims (18)

[Claims] 1. A method of compiling and linking a source file, comprising: generating global register information relating to global variables referenced in the source file by a compiler; Generating an object file comprising the global register information; generating an executable file using the global register information included in the object file to identify variable collisions and perform a relocation operation; Method with. 2. The method of claim 1, comprising linking the object file to another object file to generate the executable file. 3. The method of claim 1, comprising linking the object file to a shared library to generate the executable file. 4. The method according to claim 1, further comprising: generating a symbol table having a symbol entry for each symbol referenced in the source file, wherein each symbol entry has a symbol type. A method comprising: a symbol type field with information for identification; and a value field enabling storage of a value of said symbol type. 5. The method of claim 4, wherein selecting the symbol entry from the symbol table; and identifying information included in a symbol type of the selected symbol entry, the selected symbol entry. Determining a symbol type value of a symbol entry; and storing the value in the value field of the selected symbol entry. 6. The method of claim 5, wherein generating a relocation table comprising a plurality of relocation entries, wherein each of the relocation entries comprises information identifying a relocation type. A relocation type field, an address field including an address of one of instructions and data in the object file required for relocation, and a pointer to a specific symbol entry in the symbol table. The method further comprising: wherein the symbol entry is of a symbol type indicated by information contained in the symbol type and value fields of the particular symbol entry. 7. The method of claim 6, further comprising performing a relocation operation using a linker according to the relocation entry in the relocation table. 8. A system for compiling and linking a source file, comprising: a compiler including information generating means for generating information related to a global variable referred to in the source file; and providing the information from the source file. A system comprising: an object file generating means configured to generate an object file; and a linker configured to use the information contained in the object file to identify symbol collisions and perform a relocation operation. . 9. The system of claim 8, wherein the generating mechanism is configured to generate a symbol table comprising a symbol entry for an appropriate symbol associated with a reference in the source file. The system wherein the symbol entry further comprises: a symbol type field comprising information identifying the symbol type; and a value field comprising a value of the symbol type. 10. The system of claim 9, wherein the linker is configured to determine a value of a symbol type, and the linker stores the value in the value field of the selected symbol entry. Means for storing. 11. The system according to claim 10, wherein the generation mechanism is configured to generate a relocation table including a plurality of relocation entries, wherein each of the relocation entries has a relocation type. A relocation type field having identifying information, an address field having an address of one of instructions and data in the object file required for relocation, and a pointer to a specific symbol entry in the symbol table. Wherein the specific symbol entry is of a symbol type indicated by information included in the symbol entry;
A system further comprising: 12. The system of claim 11, wherein the linker comprises a relocation operator configured to perform a relocation operation according to the relocation entry. 13. The system of claim 8, wherein the linker is configured to link the object file with another object file to generate an executable file. 14. The system of claim 8, wherein the linker is configured to link the object file to a shared library to generate an executable. 15. A computer program product comprising a computer readable medium having computer program logic recorded thereon for enabling a computer system to compile and link a source file, wherein at compile time a global program referenced in the source file is provided. A symbol information generation mechanism for enabling the computer system to generate information relating to variables; an object file generation mechanism for enabling the computer system to generate an object file from the source file at compile time; At times, the computer system can link the object file with other existing object files or shared libraries to produce an executable file. A link mechanism for resolving symbol collisions and performing a rearrangement operation, the link mechanism including means for using the information included in the object file. 16. A computer system comprising: a processor; and a controller that enables the processor to compile and link a source file, the controller comprising, at compile time, a global variable referenced in the source file. A symbol information generation mechanism that enables the processor to generate information related to the object; and an object file generation unit that enables the processor to generate an object file including the information from the source file at the time of compilation. A linker enabling the processor to link the object file with at least one of another object file and a shared library at link time to generate an executable file, the linker comprising: Means for utilizing the information contained in the object file to identify a bol collision and perform a relocation operation. 17. A controller that enables a processor to compile and link a source file, wherein the processor can generate, at compile time, information relating to global symbols referenced in the source file. An information generating means, an object file generating means for enabling the processor to generate an object file having the information from the source file at the time of compiling, and an object file generating means for generating an executable file. Link means for enabling the processor to link the object file with at least one of another object file and a shared library,
To identify symbol collisions and perform relocation operations,
A means for using the information contained in the object file. 18. A system for compiling and linking a source file, comprising: a compiler having information generating means for generating information related to a global variable referred to in the source file; Object file generating means for generating an object file comprising said information; and a linker for linking said object file to other existing object files and a shared library to generate an executable file, wherein said linker identifies symbol collisions. And means for utilizing the information contained in the object file to perform a relocation operation.