JP2005196436A - Program-processing program, recording medium to which program-processing program is recorded, program-processing device, and program-processing method - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To generate position independence codes for a data area corresponding to a dynamic module link without changing a compiler and a linker and also generate an execution code by linking the position independence codes corresponding to the dynamic module link. <P>SOLUTION: Global variables in a module are confined in a structural body, and register-relative offset access is executed. An immediate value relative address is converted to a symbol name by a difference detection method, and the linker decides the conversion and does not link unused variables. By this, a code corresponding to a dynamic link can be generated without correcting a compiler even if the compiler does not correspond to the dynamic link. Such a method is high in portability and easily applicable to many compilers, and labor for the maintenance of the compilers is consequently reduced. <P>COPYRIGHT: (C)2005,JPO&NCIPI

Description

  A computer program is required to make the computer perform some action. This computer program is written in various languages. Among these languages, there are languages that make it easy for humans to understand the action content that the computer performs, and languages that lighten the load when the computer executes the action content.

  In order for humans to confirm the content of actions performed by a computer or to describe the contents of actions to be performed by a computer, it is necessary to have a language that is easy for humans to understand the contents of actions. This is because it is desirable that the action content be described in a language that is light on the computer when the computer executes it.

  And since the action contents to be performed by the computer confirmed by the human must be executed by the computer as it is, the description process in the language that is light on the computer is changed without changing the contents described in the language that is easy for humans to understand. It becomes necessary to do.

  Furthermore, at this time, not only the contents described in a language that is easy to understand for human beings are not changed at all, but also the processing is changed to a description in a language that is light on the computer, and the efficiency when the computer is executed is improved as much as possible. It is required to change to such a description.

  Here, the improvement in efficiency when the computer is executed means, for example, that the speed at which the computer is executed is increased, the memory size required for the computer to be executed is reduced, and the like.

  Such a process of changing to a description in a language that is light on the computer without changing the content described in a language that is easy for humans to understand is executed by the computer by a program processing program.

  The present invention relates to such a program processing program, a recording medium recording the program processing program, a program processing apparatus, and a program processing method.

  Furthermore, in recent years, a plurality of programs are loaded into the memory of one computer, and these programs are executed sequentially or in parallel. The plurality of programs may be management programs such as an OS, application programs, various other programs, or any combination thereof.

  It is desirable that these programs can be loaded and executed in memory in any combination according to the user's needs, and one of the conditions for making this possible is that each program module is assigned to any address in memory. It must be able to run when loaded.

  Dynamic program module linking, or dynamic program module linking, or combining a plurality of program modules as one program that can be executed at a free address on the memory in any combination. It is called a link or a dynamic module link.

  In order for such dynamic module linking to be possible, when the program processing program changes the content described in a language that is easy for humans to understand in a language that is light on the computer, It is necessary to perform processing that enables dynamic module linking.

  The present invention relates to a program processing program, a recording medium storing the program processing program, a program processing apparatus, and a program processing method for changing the program into a program written in a language that has a light load on a computer capable of such dynamic module linking It is about.

  For example, a conventional program processing program for changing to a program written in a language with a light load on a computer capable of dynamic module linking, a recording medium recording the program processing program, a program processing apparatus, and a program processing method include: There is a “method for linking a dynamic link library to a program” described in Patent Document 1 below.

  This traditional method uses a compiler, prelinker, and runtime library to partially link a program to dynamically load another program at application run time without requiring support for the system linker or loader. In particular, it was intended to provide a method for resolving addresses in partially linked programs.

  This could be achieved without changing the source code of the application program.

  This conventional method proposes a method for linking a dynamically linked library to a program executed on a data processing system in order to achieve the above object. The data processing system is a compiler, prelinker, and execution. Had a library, a system linker and a system loader.

  This conventional method includes the following steps.

  First, for each dynamic link library, a prelinker generates a definition file containing information about a set of external symbols available in the library, wherein the prelinker generates the definition file. The generating step of keeping up to date reflecting any changes in the dynamic link library.

  The second is a step of compiling application program code by the compiler, wherein the compiled code includes code for calling a trigger routine.

  Third, prelinking the application program code to the definition file, wherein the prelinking step includes an export definition section and generates an object deck linked by the system linker. is there.

  Fourth, there is a step of linking the application program code by the system linker.

Fifth, executing the code and resolving unresolved symbol references in the code by the trigger routine, wherein the trigger routine accesses the export definition section generated by the prelinker Enabling the runtime library to access the dynamic link library containing the unresolved symbol, load the dynamic link library, and resolve the symbol reference; Or the execution and resolution step of providing the symbol to the application program without the assistance of a loader.
JP-A-8-339296

  In the program processing program, the recording medium storing the program processing program, the program processing apparatus, and the program processing method for changing the program into a program written in a language with a light load on the computer capable of the conventional dynamic module link, In order to link modules at runtime, the compiler was modified for each processor, and the compiler generated position-independent code that could be linked at runtime.

  However, this conventional method cannot generate position-independent code corresponding to dynamic module linking unless the compiler supports it.

  Therefore, the compiler itself needs to be rewritten to generate position-independent code capable of dynamic module linking. Moreover, since the compiler exists for each processor, a huge amount of correction is required as a whole.

  Furthermore, each time a new processor is developed or upgraded, it is necessary to modify the compiler, which requires a lot of labor and increases the probability of errors. That was inevitable.

  The present invention solves these problems, and can generate position-independent code for a data area corresponding to dynamic module linking without changing the compiler or linker. The present invention relates to a program processing program, a recording medium on which a program processing program is recorded, a program processing apparatus, and a program processing method, which can generate an execution code by linking position-independent codes corresponding to.

  In order to solve the above problems, the invention according to the present patent application adopts the following means.

  The invention according to claim 1 of the present patent application is a computer program including a step of processing a computer program including a step of declaring a variable with a symbol and a step of accessing the variable declared with the symbol. A first step of setting a relative address for the variable declared in the symbol and a step of accessing the variable declared in the symbol by the relative address set in the first step. A second step of converting to a step of accessing the declared variable; a third step of adding another variable declared in the symbol before the variable declared in the symbol; and the added variable And a fourth step of setting a relative address to a variable declared with the symbol, A fifth step of converting a step of accessing a variable declared in BOL to a step of accessing a variable declared in the symbol by the relative address set in the fourth step; and the second step And the fifth step detects the accessing step in which the relative address of the accessing step converted is different from the fifth step, and the accessing step in which the relative address detected in the sixth step is different. A program processing program comprising: a seventh step of converting a variable to be accessed into a step of accessing by a declared symbol.

  The invention according to claim 2 of the present patent application is a computer program having a step of processing a computer program including a step of declaring a variable with a symbol and a step of accessing the variable declared with the symbol. A first step of adding another variable declared in the symbol before the variable declared in the symbol, and accessing the variable declared in the symbol without including the added variable The step of accessing the variable declared by the symbol including the first relative value when the step is converted to the step of accessing by the relative address of the declared variable and the added variable is the declaration. The second step of comparing with the second relative value when converted to the step of accessing with the relative address of the specified variable And the step of accessing the variable declared by the symbol different from the compared first relative value and the second relative value by accessing the variable declared by the symbol by symbol. A program processing program comprising: a third step of converting.

  In the invention according to claim 3 of the present patent application, the step of accessing the variable declared by the symbol is a step of accessing the variable declared by the symbol by indirect addressing, The program processing program according to claim 1, wherein the step of accessing a variable declared in the symbol by a relative address is a step of accessing a variable declared in the symbol by a relative address and indirect addressing.

  In the invention according to claim 4 of the present patent application, the step of accessing the variable declared by the symbol by the symbol accesses the variable declared by the symbol by relative address and indirect addressing. The program processing program according to claim 2, wherein the program processing program is a program processing program.

  The invention according to claim 5 of the present patent application is the program processing program according to claim 3 or 4, further comprising a step of setting an address variable area for the indirect addressing.

  The invention according to claim 6 of the present patent application is a program including a step of declaring the variable with a symbol and a step of performing processing on the variable declared with the symbol, in C language, or C ++ language, Or JAVA (registered trademark) language, FORTRAN language, COBOL language, BASIC language, BASIC language, APL language, PL / 1 language, LISP language, Prolog language, compiler language other than these, or other interpreter The program processing program according to any one of claims 1 to 5, wherein the program is a program described in any one or more of a language and an assembler language.

  In the invention according to claim 7 of the present patent application, the step of accessing by the symbol declaring the variable to be accessed is performed in a compiler language, an interpreted language, an assembler language, a machine language, or an intermediate language. The program processing program according to any one of claims 1 to 6, which is a step described in any one or a plurality of languages.

  The invention according to claim 8 of the present patent application is a computer-readable recording medium on which the program processing program according to any one of claims 1 to 7 is recorded.

  The invention according to claim 9 of the present patent application is a program processing apparatus for processing a computer program including a step of declaring a variable with a symbol and a step of accessing the variable declared with the symbol, A first means for setting a relative address for a variable declared in the symbol, and a step for accessing the variable declared in the symbol is declared in the symbol by the relative address set in the first step; Including a second means for converting to a step of accessing the variable, a third means for adding another variable declared in the symbol before the variable declared in the symbol, and including the added variable A fourth means for setting a relative address to the variable declared by the symbol, and access to the variable declared by the symbol; A fifth means for converting the step of accessing into the step of accessing the variable declared in the symbol by the relative address set in the fourth step, and the second step and the fifth step. The sixth means for detecting the accessing step having a different relative address in the accessing step and the accessing step having the different relative address detected in the sixth step are declared as variables to be accessed. And a seventh means for converting into a step of accessing by a symbol.

  The invention according to claim 10 of the present patent application is a program processing method for processing a computer program including a step of declaring a variable with a symbol and a step of accessing the variable declared with the symbol, A first step of setting a relative address for a variable declared in the symbol, and a step of accessing the variable declared in the symbol are declared in the symbol by the relative address set in the first step. Including a second step of converting to a step of accessing the variable, a third step of adding another variable declared in the symbol before the variable declared in the symbol, and including the added variable A fourth step of setting a relative address for a variable declared with the symbol, and an access to the variable declared with the symbol. A fifth step of converting the step of accessing the variable declared in the symbol by the relative address set in the fourth step, and converting between the second step and the fifth step. Declaring the variable to be accessed in the sixth step of detecting the accessing step having a different relative address of the accessing step and the accessing step having a different relative address detected in the sixth step, And a seventh step of converting to the step of accessing by the symbol being present.

  According to the program processing program, the recording medium on which the program processing program is recorded, the program processing apparatus, and the program processing method of the present invention, the position of the data area corresponding to the dynamic module link without changing the compiler or the linker. Independent code can be generated, and further, executable code can be generated by linking position-independent code corresponding to the dynamic module link, and its practical value is extremely large.

  Embodiments of the present invention will be described below with reference to the drawings.

(Embodiment 1)
FIG. 1 shows a program that is input to and processed by a precompiler (131), a compiler (133), and a postcompiler (135) as an embodiment of a program processing program according to the present invention. It is a figure which shows the structure of the program which these are the results of processing and which these output.

  This embodiment of the program processing program according to the present invention comprises a precompiler (131), a compiler (133), a post compiler (135), and a symbol information generation unit (142).

  The target program processed by this embodiment of the program processing program according to the present invention is the C language source program-1 (121).

  As shown in FIG. 1, the precompiler (131) of this embodiment receives C language source program-1 (121) as input, processes the input C language source program-1 (121), and performs the processing. As a result, C language source program-2 (122) and C language source program-3 (123) are output.

  The C language source program-2 (122) output from the precompiler (131) is input to the compiler (133) and is processed by the compiler (133).

  Similarly, the C language source program-3 (123) output from the precompiler (131) is also input to the compiler (133) and is processed by the compiler (133).

  Although two compilers (133) are shown in FIG. 1, they are the same as understood from the fact that they have the same numbers.

  The compiler (133) processes the input C language source program-2 (122), creates and outputs an assembler language program-1 (124), and outputs the input C language source program-3 (123). The assembler language program-2 (125) is generated and processed.

  On the other hand, the symbol information generation unit (142) also receives the C language source program-1 (121), processes the input C language source program-1 (121), and, as a result of the processing, the symbol information file ( 144) is output.

  The assembler language program-1 (124) and assembler language program-2 (125) output by the compiler (133) and the symbol information file (144) output by the symbol information generation unit (142) are the post-compiler (135). Is input and processed.

  The post compiler (135) processes the input assembler language program-1 (124), assembler language program-2 (125), and symbol information file (144) to create an assembler language program-3 (126). Output.

  The assembler language program-3 (126) created and output by the post compiler (135) is input to the assembler (137), translated by the assembler (137), and a translated result object program (127) is generated. This is output.

  This object program (127) is input to the linker (138) and processed.

  The linker (138) inputs the object program (127) output from the assembler (137) and the other object program (128), processes them, and creates and outputs an execution program (129).

  The object program (127) and the other object program (128) may each be one object program or a plurality of programs.

  The execution program (129) created and output by the linker (138) is a program that is created in a format defined by various computer specifications and can be executed by each computer as it is.

  FIG. 2 shows an example of the contents of a C language source program-1 (121) which is a target program processed by the precompiler (131) which is this embodiment of the program processing program according to the present invention, and the C language source program. -1 (121) is input to the precompiler (131), processed by the precompiler (131), and output by the precompiler (131). The C language source program-2 (122) and the C language source program-3 ( 123) and a C language source program-1 (121) are input to the symbol information generation unit (142), processed by the symbol information generation unit (142), and output as a result of the processing. ) And an example of each content.

  Further, FIG. 2 shows C language source program-2 (122) and C language source program-3 (123), which are target programs to be processed by the compiler (133), which is this embodiment of the program processing program according to the present invention. The C language source program-2 (122) and the C language source program-3 (123) are input to the compiler (133), processed by the compiler (133), and output by the compiler (133). Also shown are examples of the contents of the assembled assembler language program-1 (124) and assembler language program-2 (125).

  In FIG. 4, only the main processes performed by the precompiler (131), the compiler (133), and the post compiler (135), which are embodiments of the program processing program according to the present invention, are numbered starting with “S”. It is attached according to the time series.

  Further, FIG. 5 shows a computer environment in which the precompiler (131), the compiler (133), the post compiler (135), and the symbol information generation unit (142), which are embodiments of the program processing program according to the present invention, are executed. The main configuration is shown.

  These precompiler (131), compiler (133), postcompiler (135), C language source program-1 (121), language source program-2 (122), language source program-3 (123), assembler language program -1 (124), assembler language program-2 (125), assembler language program-3 (126), or assembler (137), linker (138), symbol information generation unit (142), object program (127), etc. The object program (128), the symbol information file (144), the execution program (129), and other necessary programs and data are stored in the auxiliary storage device (503), and the main storage ( 502) and the CPU (501) Therefore, execution and processing is carried out. These executions and processes performed by the CPU are selected and activated by the operator using the input device (504). The results of the execution and processing performed by the CPU may be displayed on the display device (505) or may be stored in the main storage device (502), and may be stored in the auxiliary storage device (503) as necessary. Stored and communicated by the communication device (506) as necessary. Transfer of these programs and data between the CPU (501), the main storage device (502), the auxiliary storage device (503), the input device (504), the display device (505), the communication device (506), and other devices and members Is performed via the bus (507).

  The computer environment may include other members and devices, but details thereof are omitted.

  In the example shown in FIG. 2, the first program to be processed in this embodiment of the program processing program according to the present invention is C language source program-1 (121) described in C language.

  However, the first program to be processed in this embodiment does not necessarily have to be written in the C language, and other languages such as C ++ language, JAVA (registered trademark) language, or FORTRAN language, Or COBOL language, or BASIC language, or APL language, or PL / 1 language, or LISP language, or Prolog language, or any other compiler language, or any other interpreted language, or any assembler language, or It may be a program written in a combination of a plurality of languages.

  As shown in FIG. 2, this C language source program-1 (121) includes a part that declares global variables (external variables) used in this program, and these declared global variables and other local variables ( It can be divided into function parts that describe processing to be performed using internal variables.

  In the example of the C language source program-1 (121), the parts declaring global variables (external variables) are “int var_a;” and “int var_b;”.

  This declares the use of two global variables, var_a and var_b, and declares that these two global variables together handle integer data.

  In the example of the C language source program-1 (121), the function part describing the process is from “void func1 (void) {” to “}”.

  In this function portion, the processing content of the function named “func1” is described. Specifically, this function has no return value (void) and no argument (void). ) Is declared.

  As specific processing contents, only processing for substituting the value “40” into the global variable named “var_b” is described.

  In this example, only such specific processing contents are simply described, but actually, various types of processing are included, and these are expressed by omitting them by the symbol “:”.

  As shown in FIG. 2, the precompiler (131) which is this embodiment of the program processing program according to the present invention reads this C language source program-1 (121) as input information (S401 in FIG. 4), Processing is performed to generate and output C language source program-2 (122) and C language source program-3 (123).

  That is, the processing performed by the precompiler (131) referred to here generates C language source program-2 (122) and C language source program-3 (123) from C language source program-1 (121). It is processing.

  More specific processing contents will be described next.

  The C language source program-2 (122) declares what was declared as an external variable in the C language source program-1 (121) as a member of a global structure (sometimes called an external structure). It has been fixed. The description of the process for accessing the variable is changed from the access to the external variable to the description of the process for accessing the member of the global structure.

  Here, only variables that have been declared as external variables will be described, but they may include internal variables and external variables that have been declared static.

  That is, in the C language source program-2 (122), first, a structure named “_globals” is declared as a global structure.

  The name of the structure is an example and is not limited to this. Any name may be used as long as it does not overlap with other names.

  Next, a description of “int var_a;” and “int var_b;”, which are descriptions declared as external variables in the C language source program-1 (121), is used as a member of the declared global structure (_globals). The declarations are replaced with descriptions of “int var_a;” and “int var_b;”.

  Next, in the C language source program-2 (122), at the beginning of the function describing the process, it is described that the start address of the declared global structure (_globals) is held in the register “DP”. Yes.

  Note that holding the start address of this global structure in the “DP” register is an example, and other registers may be used to hold the start address of the global structure. May be used, or a method of holding using other memory areas may be used. The access method to the global structure described below only changes depending on the method for holding the start address of the global structure.

  Furthermore, in the C language source program-1 (121), access is made to “var_b = 40;” which is a description for accessing the external variable var_b and assigning the value “40” to the global structure member var_b. Thus, the description “globals_ptr → var_b = 40;” corresponding to the process of substituting the value “40” is rewritten.

  The entity of globals_ptr is the register “DP” based on the description that holds the start address of the global structure in the “DP” register.

  The C language source program-3 (123) is almost the same as the C language source program-2 (122).

  The only difference is that “int_dummy;” is described at the beginning of the declaration of the members of the declared global structure (_globals) (S404 in FIG. 4).

  A declaration as a member of the declared global structure (_globals), which replaces the description of “int var_a;” and “int var_b;”, which are descriptions declared as external variables in the C language source program-1 (121) A description of “int var_a;” and “int var_b;” is described after _dummy.

  The C language source program-3 (123) is different from the C language source program-2 (122) only in this portion, and the other portions are exactly the same.

  As shown in FIG. 2, the C language source program-2 (122) and the C language source program-3 (123) generated in this way are compiled by the compiler (133), and each of them is an assembler language program-1. (124) and assembler language program-2 (125) are converted and generated.

  Both of these two assembler language programs describe a process of assigning the value “40” to var_b which is a member of the global structure.

  The specific contents are as follows.

  In both assembler language program-1 (124) and assembler language program-2 (125), the first instruction “mov 40, D0” indicates that the value “40” is stored in the register D0. Yes.

  The second instructions “mov D0, (4, DP)” and “mov D0, (8, DP)” are instructions for moving the value “40” stored in the register D0 to the variable var_b. Indirect access is performed using a value obtained by adding “4” or “8”, which is a relative address (also referred to as an offset address) value, to the contents of the register DP, and moving the contents of the register D0. (S403 and S406 in FIG. 4).

  That is, the variable var_b is a member of the global structure_globals, and the start address of the global structure_globals is stored in the register DP by the first description of the function func1.

  The variable var_b is the second member of the global structure _globals in the C language source program-2 (122) and the third member in the C language source program-3 (123). Source program-2 (122) has one integer type member var_a before it, and C language source program-3 (123) has two integer type members _dummy and var_a before them. Occupies an area of 4 bytes and 8 bytes in the global structure, so in the assembler language program-1 (124), the contents of the register DP plus “4” as the offset address value are used for indirect access. And register in assembler language program-2 (125) Performing indirect access to the contents of P as a target address value obtained by adding "8" as an offset address value (S402 and S405 in FIG. 4).

  Thus, “40” that is the content of the register D0 can be stored in the variable var_b that is a member of the global structure.

  On the other hand, the C language source program-1 (121) is also input to the symbol information generation unit (142), processed by the symbol information generation unit (142), and a symbol information file (144) is created and output. As shown in FIG. 2, the contents of this symbol information file (144) are the names of all external variables declared by the C language source program-1 (121) and the areas used for the external variables. It is a table | surface which shows a response | compatibility with relative address.

  As shown in FIG. 1, the assembler language program-1 (124), the assembler language program-2 (125), which are two assembler language programs generated and output by the compiler 133, and the symbol information generation unit (142) are generated and output. Both the symbol information file (144) is input to the post compiler (135) and is subjected to processing performed by the post compiler (135).

  As a result of processing by the post compiler (135), an assembler language program-3 (126) is generated and output.

  FIG. 3 shows an example of this state and a program that is input to the post compiler (135) and output from the post compiler (135).

  As shown in FIG. 3 and as understood from the above description, the post-compiler (135) is inputted with two assembler language programs generated and output by the compiler (133), that is, an assembler language program-1 (124). The assembler language program-2 (125) and the symbol information file (144) generated and output by the symbol information generation unit (142).

  Therefore, the contents of these two assembler language programs and the symbol information file (144) are the same as those shown in FIG.

  The post compiler (135) first inputs these two assembler language programs and detects the difference, that is, a different part (S407 in FIG. 4).

  In the example shown in FIG. 3, “mov D0, (4, DP)” and “mov D0, (second instructions) of the assembler language program-1 (124) and the assembler language program-2 (125). 8, DP) ", only the offset address for the register DP is different.

  Next, the post-compiler (135) that has detected this difference performs processing on this different part, that is, the register DP of “mov D0, (4, DP)”, which is the second instruction of the assembler language program-1 (124). The offset address “4” is searched in the symbol information file (144), and the name “var_b” of the external variable corresponding to this “4” is detected.

  The offset address “4” with respect to the register DP of “mov D0, (4, DP)” of the second instruction of the assembler language program-1 (124), which is this different part, is used as the name of this external variable “var_b”. ", That is," mov D0, (var_b, DP) "is generated and output (S408 in FIG. 4).

  The same part of the two assembler language programs is output as it is.

  In this way, the post compiler 135 generates and outputs an assembler language program-3 (126).

  The assembler language program-3 (126) is input to the assembler (137), assembled, and an object program (127) is generated and output. In the object program (127), an instruction, for example, “mov” in the above example is converted into a machine language instruction, the relative address of the operand is calculated and stored, and is subject to area allocation by the linker described later. Since the subsequent processing including this processing is the same as the conventional assembly and link processing, only a brief description will be given.

  The object program (127) is input to the linker (138) together with the other object program (128), linked, and an execution program (129) is generated and output.

  In this link processing, instructions necessary for completing one work are grouped into one, areas used by this group of instructions are grouped into one, and area allocation is performed. This is the execution program (129).

  In this example, an external variable (“var_a”, “var_b”) is declared as a member of the structure by the precompiler (131), and the start address “globals_ptr” of the structure is set in the register “DP” as the base address of the relative address. , And the DP relative access is generated by rewriting the access “var_b = 40;” to the external variable to the structure access “globals_ptr−> var_b = 40;”, but the precompiler (131) #Define instructions (for example, “#define var_a 0”, “#define var_b 1”) are assigned unique numbers to external variables (“var_a”, “var_b”) and replaced with numbers other than the definition of external variables. And the base address of the relative address Prepare the pointer variable “base_ptr” as follows, hold the address in the register “DP”, and change the relative access by rewriting “var_b = 40;” to “* (base_ptr + var_b) = 40;” to the external variable. It may be generated.

  The precompiler (131) assigns a unique number to the external variable, prepares an array as a base address of the relative address, holds the address in the register “DP”, and accesses the external variable in advance. The DP relative access may be generated by rewriting the array access using the number assigned to the external variable as an index.

  According to this configuration, the symbol information generation unit (142) does not need the information of the compiler (133) in order to create the symbol information file (144). It can be made independent.

(Embodiment 2)
Next, a second embodiment of the program processing program according to the present invention will be described. However, since the second embodiment is the same as the first embodiment in many respects, the description of the same parts will be omitted and only the different points will be described.

  FIG. 1 is also a diagram showing a configuration of a program that is a second embodiment of the program processing program according to the present invention, a processing target of the program, and a program that is output as a result of processing. However, in the description of the second embodiment, it is distinguished from the first embodiment by changing the numbers such as the precompiler (631), the compiler (633), and the post compiler (635).

  Therefore, the second embodiment of the program processing program according to the present invention includes a precompiler (631), a compiler (633), a post compiler (635), and a symbol information generation unit (642).

  The target program processed by the second embodiment of the program processing program according to the present invention is C language source program-1 (621).

  The precompiler (631) of the second embodiment receives the C language source program-1 (621), processes the input C language source program-1 (621), and, as a result of the processing, the C language source Program-2 (622), C language source program-3 (623), and C language source program (652) are output.

  The C language source program-2 (622) output from the precompiler (631) is input to the compiler (633) and is subjected to processing by the compiler (633).

  Similarly, the C language source program-3 (623) output from the precompiler (631) is also input to the compiler (633) and is processed by the compiler (633).

  Similarly, the C language source program (652) output by the precompiler (631) is also input to the compiler (633) and is processed by the compiler (633).

  The compiler (633) processes the input C language source program-2 (622), creates and outputs an assembler language program-1 (624), and processes the input C language source program-3 (623). Then, the assembler language program-2 (625) is generated and output, the input C language source program (652) is processed, and the assembler language program (654) is generated and output.

  On the other hand, the symbol information generation unit (642) also receives the C language source program-1 (621), processes the input C language source program-1 (621), and, as a result of the processing, the symbol information file ( 644) is output.

  The assembler language program-1 (624) and assembler language program-2 (625) output from the compiler (633) and the symbol information file (644) output from the symbol information generation unit (642) are the post-compiler (635). Is input and processed.

  The post compiler (635) processes the input assembler language program-1 (624), assembler language program-2 (625), and symbol information file (644) to create an assembler language program-3 (626). Output.

  The assembler language program-3 (626) created and output by the post compiler (635) is input to the assembler (137), translated by the assembler (137), and a translated result object program (127) is generated. This is output.

  The processing performed by the assembler (137) is the same as that of the first embodiment of the present invention.

  The object program (127) is input to the linker (138) together with the other object program (128), linked, and an execution program (129) is generated and output. At this time, the assembler language program (654) is used to determine the address of the symbol variable _dml_var_e. This process is different from the first embodiment of the present invention.

  Since the subsequent processing is the same as that of the first embodiment, description thereof is omitted.

  FIG. 6 shows an example of the contents of a C language source program-1 (621) that is a target program to be processed by the precompiler (631) of the second embodiment of the program processing program according to the present invention, and the C language. Source program-1 (621) is input to the precompiler (631), processed by the precompiler (631), and output by the precompiler (631). C language source program-2 (622) and C language source program- 3 (623), the C language source program (652), and the C language source program-1 (621) are input to the symbol information generation unit (642) and processed by the symbol information generation unit (642). An example of the contents of the symbol information file (644) output as a result It is to figure.

  Further, FIG. 6 shows C language source program-2 (622) and C language source program-3 (623) which are target programs processed by the compiler (633) which is the second embodiment of the program processing program according to the present invention. And C language source program (652), and this C language source program-2 (622), C language source program-3 (623), and C language source program (652) are compilers (633). The contents of assembler language program-1 (624), assembler language program-2 (625), and assembler language program (654) that are input to, processed by the compiler (633), and output by the compiler (633) It is a figure which also shows an example.

  In the example shown in FIG. 6, the first program to be processed in the second embodiment of the program processing program according to the present invention is C language source program-1 (621) described in C language.

  As shown in FIG. 6, this C language source program-1 (621) is different from the C language source program (121) of the first embodiment in that it is declared as an external variable in another C language source program. It includes “extern int var_e” that is a declaration of a reference to a variable, and “var_e = 40” that is a statement that assigns the value “40” to the referenced external variable “var_e”.

  However, the other C language source program here refers not only to a program other than the C language source program-1 (621), but also, for example, grouped C language source programs, and this C language source program-1 It may be a C language source program belonging to a group other than the group to which (621) belongs. A group of C language source programs belonging to one group divided in this way may be referred to as a module.

  As shown in FIG. 6, the precompiler (631), which is the second embodiment of the program processing program according to the present invention, reads this C language source program-1 (621) as an input (S401 in FIG. 4) and performs processing. The C language source program-2 (622), the C language source program-3 (623), and the C language source program (652) are generated and output.

  The C language source program-2 (622) re-declares “var_b”, which has been declared as an external variable in the C language source program-1 (621), as a member of the global structure, and at the same time, When a description for accessing a variable “var_e” declared as an external variable in the source program is included, a pointer variable _dml_var_e to the external variable is newly created, and the pointer variable is declared as an external variable. , Added as a member of this global structure “_globals”.

  At the same time, the precompiler (631) generates and outputs a C language program (652) for securing an area for the pointer variable_dml_var_e.

  Then, a description for accessing a variable “var_e” declared as an external variable in another C language source program is used as a description for indirect access using a pointer to the external variable that is a member of the global structure “*”. (_Globals_prt-> _ dml_var_e) = 40 ".

  Next, in the C language source program-2 (622), the start address of the declared global structure (_globals) is held in the register “DP” at the beginning of the function (func1) describing the process. Is described. It should be noted that holding the start address of this global structure in the “DP” register is also an example, and other registers and memories may be used.

  Further, in the C language source program-2 (622), “var_e = 40;” which is a description for accessing the external variable var_e and substituting the value “40” in the C language source program-1 (621), The pointer variable _dml_var_e, which is a member of this global structure, is used and replaced with the description “* (globals_ptr −> _ dml_var_e) = 40;” which is a process of substituting the value “40” by indirect access.

  The C language source program-3 (623) is almost the same as the C language source program-2 (622).

  The only difference is that a description “int_dummy;” is added to the beginning of the member declaration of the declared global structure (_globals) (S404 in FIG. 4).

  In the C language source program-3 (623), the description of “int var_b;” and “int * _dml_var_e;” declared as members of the global structure (_globals) in the C language source program-2 (621) is , “Int_dummy”, which is a member declaration of the added global structure (_globals), is described subsequently.

  The C language source program-3 (623) is different from the C language source program-2 (622) only in this portion, and the other portions are exactly the same.

  As shown in FIG. 6, the C language source program-2 (622) and the C language source program-3 (623) generated in this way are compiled by a compiler (633), and each of them is an assembler language program-1. (624) and assembler language program-2 (625) are converted and generated.

  The C language source program (652) is also compiled by the compiler, and the assembler language program (654) is converted and generated.

  Two assembler language programs, assembler language program-1 (624) and assembler language program-2 (625), are variables declared as external variables in the original C language source program-1 (621). A process of substituting the value “40” by indirect access using “_dml_var_e” which is a member of the global structure is described for “var_e”.

  The specific contents are as follows.

  In both assembler language program-1 (624) and assembler language program-2 (625), the first instruction “mov 40, D0” indicates that the value “40” is stored in the register D0. Yes.

  The second instructions "mov (4, DP), A0" and "mov (8, DP), A0" are the contents of the memory address area obtained by adding 0 or 4 as the offset address to the contents of the register DP, respectively. Is transferred to the register A0.

  The memory address area obtained by adding 0 or 4 as the offset address to the contents of the register DP, as understood from the C language source program-2 (622) and the C language source program-3 (623), is the pointer variable _dml_var_e. It is an area.

  The third instruction “mov D0, (A0)” in both assembler language program-1 (624) and assembler language program-2 (625) is the indirect using register A0. It indicates that data is stored in the memory area by access.

  On the other hand, the C language source program-1 (621) is also input to the symbol information generation unit (642), processed by the symbol information generation unit (642), and a symbol information file (644) is generated and output. As shown in FIG. 6, the contents of the symbol information file (644) include the name of the external variable declared by the C language source program-1 (621) and the relative area used for the external variable. In addition to showing the correspondence with the address (offset address from the beginning), the C language source program-1 (621) includes a description for accessing a variable declared as an external variable in another C language source program. The table sometimes shows the correspondence between the pointer variable used for the access and the relative address (offset address from the head) of the area used for the pointer variable.

  As shown in FIG. 7, the assembler language program-1 (624), the assembler language program-2 (625), and the symbol information generation unit (642), which are two assembler language programs generated and output by the compiler (633), are generated. Both the output symbol information file (644) is input to the post compiler (635) and subjected to processing performed by the post compiler (635).

  As a result of processing by the post compiler (635), an assembler language program-3 (626) is generated and output.

  FIG. 7 shows an example of this state, a program input to the post compiler (635), and a program output from the post compiler (635).

  As shown in FIG. 7 and as can be understood from the above description, the post-compiler (635) is inputted with two assembler language programs generated and output by the compiler (633), that is, an assembler language program-1 (624). The assembler language program-2 (625) and the symbol information file (644) generated and output by the symbol information generation unit (642).

  Accordingly, the contents of these two assembler language programs and the symbol information file (644) are the same as those shown in FIG.

  The post compiler (635) first inputs these two assembler language programs and detects the difference, that is, a different portion (S407 in FIG. 4).

  In the example shown in FIG. 7, the second instructions “mov (4, DP), A0” and “mov (8, 8) of assembler language program-1 (624) and assembler language program-2 (625) are used. DP), A0 ", only the offset address for the register DP is different.

  Next, the post-compiler (635) that has detected this difference performs processing on this different part, that is, the register DP of “mov (4, DP), A0”, which is the second instruction of the assembler language program-1 (624). The offset address “4” is searched in the symbol information file (644), and the name “_dml_var_e” of the external variable corresponding to this “4” is detected.

  The offset address “4” with respect to the register DP of “mov (4, DP), A0” of the second instruction of the assembler language program-1 (624), which is this different part, is used as the name of this external variable “_dml_var_e”. ", That is," mov (_dml_var_e, DP), A0 "is generated and output (S408 in FIG. 4).

  The same part of the two assembler language programs is output as it is.

  In this way, the post compiler 635 generates and outputs an assembler language program-3 (626).

  The assembler language program-3 (626) created and output by the post compiler (635) is input to the assembler (137), translated by the assembler (137), and a translated result object program (127) is generated. This is output.

  The processing performed by the assembler (137) is the same as that of the first embodiment of the present invention.

  The object program (127) is input to the linker (138) together with the other object program (128), linked, and an execution program (129) is generated and output. At this time, the assembler language program (654) is used to determine the address of the symbol variable _dml_var_e. This process is different from the first embodiment of the present invention.

  Since the subsequent processing is the same as that of the first embodiment, description thereof is omitted.

  The present invention is not limited only to information processing equipment, and for example, even in home electrical equipment and office electrical equipment, without changing the compiler, while still using the currently used compiler as it is, and efficiently It can be used to generate dynamic program modules.

The figure which shows the structure of the program which is Embodiment 1 of the program processing program which concerns on this invention, and the object program which these process The figure which shows the example of the program which the precompiler which is Embodiment 1 of the program processing program which concerns on this invention outputs The figure which shows the example of the program which the post compiler which is Embodiment 1 of the program processing program which concerns on this invention outputs The figure which shows the main processes which the program which is Embodiment 1 of the program processing program which concerns on this invention performs according to a time series The figure which shows the main structures of the computer environment in which the program which is Embodiment 1 of the program processing program which concerns on this invention is performed The figure which shows the example of the program which the precompiler which is Embodiment 2 of the program processing program which concerns on this invention outputs The figure which shows the example of the program which the post-compiler which is Embodiment 2 of the program processing program which concerns on this invention outputs

Explanation of symbols

121,621 C source program-1
122,622 C language source program-2
123,623 C source program-3
124,624 Assembler language program-1
125,625 Assembler language program-2
126,626 Assembler language program-3
127 Object program 128 Other object program 129 Execution program 131,631 Precompiler 133,633 Compiler 135,635 Post compiler 137 Assembler 138 Linker 142,642 Symbol information generation unit 144,644 Symbol information file 501 CPU
502 Main storage device 503 Auxiliary storage device 504 Input device 505 Display device 506 Communication device 507 Bus

Claims (10)

A computer program comprising the steps of processing a computer program comprising: declaring a variable with a symbol; and accessing the variable declared with the symbol,
A first step of setting a relative address for a variable declared with the symbol;
A second step of converting the variable declared in the symbol to the step of accessing the variable declared in the symbol by the relative address set in the first step;
A third step of adding another variable declared in the symbol before the variable declared in the symbol;
A fourth step of setting a relative address for variables declared in the symbol including the added variable;
A fifth step of converting the step of accessing the variable declared in the symbol to the step of accessing the variable declared in the symbol by the relative address set in the fourth step;
A sixth step of detecting the accessing step in which the relative address of the accessing step converted in the second step and the fifth step is different;
A seventh step of converting the step of accessing different relative addresses detected in the sixth step into a step of accessing by a symbol declaring the variable to be accessed;
Having
Program processing program. A computer program comprising the steps of processing a computer program comprising: declaring a variable with a symbol; and accessing the variable declared with the symbol,
A first step of adding another variable declared in a symbol before a variable declared in the symbol;
The step of accessing the variable declared by the symbol without including the added variable is converted to the step of accessing by the relative address of the declared variable, and the first relative value is added. A step of accessing a variable declared by the symbol including a variable is compared with a second relative value when the step of accessing a variable addressed by the relative address of the declared variable is compared with a second relative value Steps,
A step of accessing a variable declared by the symbol having a different first relative value and a second relative value compared to a step of accessing the variable declared by the symbol by a symbol; And the steps
Having
Program processing program. Accessing a variable declared in the symbol by the relative address is accessing a variable declared in the symbol by a relative address and indirect addressing;
The program processing program according to claim 1. The step of accessing the variable declared by the symbol by the symbol is a step of accessing the variable declared by the symbol by relative address and indirect addressing.
The program processing program according to claim 2. Setting an address variable area for the indirect addressing,
The program processing program according to claim 3 or 4. A program including the step of declaring the variable with a symbol and the step of processing the variable declared with the symbol,
C language, or C ++ language, JAVA (registered trademark) language, FORTRAN language, COBOL language, BASIC language, BASIC language, APL language, PL / 1 language, LISP language, Prolog language, or other compiler The program processing program according to any one of claims 1 to 5, wherein the program is a program described in any one or a plurality of languages, an interpreted language other than these, or an assembler language. The step of accessing by a symbol declaring the variable to be accessed is as follows:
The program processing according to any one of claims 1 to 6, which is a step described in one or more of a compiler language, an interpreter language, an assembler language, a machine language, and an intermediate language. program. A computer-readable recording medium,
The recording medium which recorded the program processing program of any one of Claims 1-7. A program processing apparatus for processing a computer program comprising the steps of declaring a variable with a symbol and accessing the variable declared with the symbol,
First means for setting a relative address for a variable declared with the symbol;
A second means for converting the step of accessing the variable declared in the symbol to the step of accessing the variable declared in the symbol by the relative address set in the first step;
A third means for adding another variable declared in the symbol before the variable declared in the symbol;
A fourth means for setting a relative address for variables declared by the symbol including the added variable;
A fifth means for converting the step of accessing the variable declared in the symbol to the step of accessing the variable declared in the symbol by the relative address set in the fourth step;
A sixth means for detecting the accessing step in which the relative address of the accessing step converted in the second step and the fifth step is different;
A seventh means for converting an access step having a different relative address detected in the sixth step into an access step by a symbol declaring a variable to be accessed;
Having
Program processing device. A program processing method for processing a computer program comprising the steps of declaring a variable with a symbol and accessing the variable declared with the symbol,
A first step of setting a relative address for a variable declared with the symbol;
A second step of converting the step of accessing the variable declared in the symbol to the step of accessing the variable declared in the symbol by the relative address set in the first step;
A third step of adding another variable declared in the symbol before the variable declared in the symbol;
A fourth step of setting a relative address for variables declared by the symbol including the added variable;
A fifth step of converting the step of accessing the variable declared in the symbol to the step of accessing the variable declared in the symbol by the relative address set in the fourth step;
A sixth step of detecting the accessing step in which the relative address of the accessing step converted in the second step and the fifth step is different;
A seventh step of converting the step of accessing different relative addresses detected in the sixth step to the step of accessing by a symbol declaring the variable to be accessed;
Having
Program processing method.

Images