JP2001325120A - Information processor - Google Patents

Abstract

PROBLEM TO BE SOLVED: To inspect the undefined reference of a dynamic variable. SOLUTION: A dynamic variable specification means 2 specifies a target dynamic variable form a source file 1. An area specification means 3 specifies an area to be secured in the case of developing the dynamic variable specified by the means 2 on a memory 5 at the time of carrying out a load module. An initializing means 4 initializes the area specified by the means 3 by a prescribed initial value.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to an information processing apparatus, and more particularly to information which translates a source code including a dynamic variable into an object code by a compiling process, converts the source code into an executable load module by a linking process, and executes it. It relates to a processing device.

[0002]

2. Description of the Related Art Variables used in languages such as FORTRAN and the C language can be classified into two types, static variables and dynamic variables, depending on the arrangement in a memory at the time of execution. A static variable is a variable whose allocation to a storage area is invariant regardless of the execution process of a program.
A dynamic variable is a variable to which a storage area is allocated during execution of a program.

When writing programs in these languages, it is necessary to set initial values for variables to be used. This is because if a variable is referred to without setting an initial value, an unexpected error may occur because the value of the variable is undecided.

[0004] A similar problem exists with arrays.
In other words, in the case of an array, if the array subscript exceeds the declared range, it refers to an undefined area.
In this case, the same problem as in the case described above occurs.

[0005]

Conventionally, the following two methods are generally used for checking whether a variable that has not been initialized is referred to (hereinafter referred to as an undefined reference check). Had been. (1) An instruction for setting a predetermined initial value for a target variable is added to a program. If the predetermined value is detected during execution of the program, it is determined that an undefined variable is being referred to. to decide. (2) At the time of compiling, the compiler assigns a predetermined initial value to a target variable, and when the value is detected at the time of executing the program, it is determined that an undefined variable is used.

In addition, the following two methods have been generally used as a check for referring to an array subscript in a range that is not declared (hereinafter, referred to as an array subscript check). (3) The programmer directly refers to the contents of the array subscript, for example, by adding an instruction to print out the array subscript to the program. (4) At compile time, the compiler detects an instruction that refers to an array from the program, and adds a new instruction before and after the instruction to check whether or not the array subscript exists in an appropriate range.

In the methods (1) and (3), however, there is a problem that it is complicated since a new instruction must be added manually by a programmer. Also,
In the case of the methods (2) and (4), it is necessary to compile the program again, and there is a problem that it is not efficient for a program requiring a long time for compiling.

Further, the methods (2) and (4) have a problem that an initial value cannot be set for the above-mentioned dynamic variables. This will be described in detail below. That is, a dynamic variable is a variable whose allocation to a memory area is determined for the first time when a program is executed,
The allocation destination is managed by an OS (Operating System). Therefore, in order to initialize the contents of a variable with a predetermined value, it is necessary to know the area allocated by the OS. However, since such a method has not existed in the past, a dynamic variable is set to an arbitrary value. Was difficult to initialize.

The present invention has been made in view of such a point, and an object of the present invention is to provide an information processing apparatus capable of initializing a dynamic variable with an arbitrary value by a debug option.

[0010]

According to the present invention, in order to solve the above-mentioned problems, a source file 1 including dynamic variables shown in FIG. 1 is translated into an object file by a compiling process, and is converted into an executable file by a linking process. In an information processing apparatus for converting into a load module, a dynamic variable specifying unit 2 for specifying a target dynamic variable from the source file 1 and a dynamic variable specified by the dynamic variable specifying unit 2 are loaded into the load module. Area specifying means 3 for specifying an area secured when the module is expanded on the memory 5 during execution of the module, and initialization means 4 for initializing the area specified by the area specifying means 3 with a predetermined initial value.
And an information processing apparatus characterized by having the following.

The dynamic variable specifying means 2 includes a source file 1
Specify the target dynamic variable from. Area specifying means 3
Specifies an area secured when the dynamic variable specified by the dynamic variable specifying means 2 is expanded on the memory 5 when the load module is executed. The initialization means 4 initializes the area specified by the area specification means 3 with a predetermined initial value.

Also, in an information processing apparatus for translating a source file including an array into an object file by a compiling process and converting the source file into an executable load module by a link process, an array specifying device for specifying a target array from the source file Means, an area securing means for securing an area on the memory at the time of execution of the load module, an area larger than the area declared in the array identified by the array identifying means by a predetermined number of bytes, and the area securing means And an initialization unit for initializing the area secured by the above with a predetermined initial value.

Here, the array specifying means specifies a target array from the source file. The area securing means secures an area larger by a predetermined number of bytes than the area declared in the array specified by the array specifying means on the memory when the load module is executed. The initialization means initializes the area secured by the area securing means with a predetermined initial value.

[0014]

Embodiments of the present invention will be described below with reference to the drawings. FIG. 1 is a principle diagram for explaining the operation principle of the present invention. In this figure, the source code is
For example, it is a program described in FORTRAN or C language, and includes dynamic variables.

[0015] The dynamic variable specifying means 2 includes:
Specify the target dynamic variable from. Area specifying means 3
Specifies an area secured when the dynamic variable specified by the dynamic variable specifying means 2 is expanded on the memory at the time of execution.

The initializing means 4 initializes the area specified by the area specifying means 3 with a predetermined initial value.
The memory 5 stores a load module generated by compiling and linking the source file 1.

Next, the operation of the above principle diagram will be described. Now, assuming that a source file 1 including a dynamic variable is input, the dynamic variable specifying means 2
Identify dynamic variables from

The area specifying means 3 specifies an area when the dynamic variable specified by the dynamic variable specifying means 2 is expanded in the memory 5. More specifically, the area specifying means 3 obtains, in the object file, the relative addresses (the start address and the end address) at which the object codes related to the target dynamic variables are stored, and Supply.

When the program is executed, the initialization means 4 dynamically determines the starting address (absolute address) of the memory in which the object code is stored, and the starting address and the ending address (relative address). The absolute address of the memory in which the variable is stored is specified, and the initial value (in this example, “8
B ”) initializes the area.

As a result, the area of the memory 5 to which the dynamic variables are assigned is initialized with a predetermined initial value. As described above, according to the information processing apparatus according to the present invention, it is possible to initialize a dynamic variable with an arbitrary value. Inspection becomes possible.

Next, an embodiment of the present invention will be described with reference to FIGS. FIG. 2 is a diagram illustrating a configuration example of the embodiment of the present invention. As shown in this figure,
The information processing apparatus 10 according to the present invention includes a CPU (Central Pr
Ocessing Unit) 10a, ROM (Read Only Memory)
10b, RAM (Random Access Memory) 10c, HD
D (Hard Disk Drive) 10d, GC (Graphics Card)
10e, I / F (Interface) 10f, and bus 1
The display device 11 and the input device 12 are connected to the outside.

Here, the CPU 10a controls various parts of the apparatus and executes various arithmetic processes according to programs and the like stored in the HDD 10d. ROM 10b
Stores basic programs executed by the CPU 10a, data, and the like.

The RAM 10c temporarily stores programs being executed by the CPU 10a, data being calculated, and the like. The HDD 10d stores an OS for controlling the entire system, a compiler, a debugger, a linker, a source file to be compiled, an object file after compilation, and the like.

The GC 10e executes a drawing process according to a drawing command supplied from the CPU 10a, converts the obtained image data into a video signal, and outputs the video signal to the display device 11. I
The / F10f converts the expression format of the data supplied from the input device 12 and inputs the converted data.

The bus 10g includes a CPU 10a, a ROM 10
b, the RAM 10c, the HDD 10d, the GC 10e, and the I / F 10f are interconnected, and data can be exchanged among them.

The display device 11 is, for example, a CRT (Cathod).
e Ray Tube) monitor, and displays and outputs an image signal supplied from the GC 10e. The input device 12
For example, it is constituted by a keyboard or a mouse, generates data according to a user operation, and supplies the data to the I / F 10f.

Here, the OS, compiler, linker, source file, and object file are stored on the HDD.
10d, read as needed and read R
It is developed in the AM 10c and executed by the CPU 10a.

FIG. 3 is a diagram schematically showing the correspondence among the OS 20, the compiler 20a, the linker 20b, the source file 21, the library 22, and the load module 23.

As shown in this figure, the OS 20 manages the execution of the compiler 20a and the linker 20b, reads out the source file 21 and the library 22 stored in the HDD 10d in response to a request from the compiler, and generates and generates the library. Load module 23 to HD
D10d is stored. When an execution request for the load module is made from the input device 12,
The corresponding load module stored in the HDD 10d is read and executed.

Here, the library 22 is composed of, for example, a mathematical function library for calculating a mathematical function, an initialization library for performing initialization processing when executing a load module, and the like. When executing the link processing, it is read as needed.

Next, an outline of the operation of the embodiment of the present invention will be described with reference to FIG. First, Compiler 2
When the source file 30 is supplied to 0a, the compiler 20a detects a dynamic variable included in the source file 30. In this example, "DIMENSIO
Array A declared by "NA (1000)"
(Local variable without initial value) and "COMMON /
The array B (global variable without an initial value) declared by “BLK / B (1000)” is detected as a target dynamic variable.

Next, the compiler 20a embeds the detected dynamic variable in an object file as a variable of a new data section (hereinafter, referred to as a new data section), and executes the same for another instruction group described in the source file 30. After performing the compiling process, the obtained object file 31 is output.

In this example, the object file 31 has an object code “.bssnew1 main.
local, 4000 "and" .common1 "
blk, 4000 ". Here, "b
"ss" is the section name, "main" and "loc
“al” indicates that the variable is a local variable belonging to the main function, and “4000” indicates that an area of 4000 bytes (because a single-precision real number is composed of 4 bytes) is secured. “Common” is a common variable, and “blk” is a name given to an area to be secured.

When a similar program is compiled by a conventional compiler, ".bss mai"
n. local, 4000 "and" .common bl
k, 4000 ”, and the substantial difference is“ new
1 "only.

The linker 20b performs link processing on the object file 31 output from the compiler 20a. That is, the linker 20b first
The initialization library 22a and necessary libraries are read out from the library and added to the object file 31.

Here, the initialization library 22a is composed of a group of instructions to be executed first when a load module is executed. In the present embodiment, the initialization library 22a uses the initialization library 22a to execute a desired operation. Performs initialization of dynamic variables.

Subsequently, the linker 20b searches for a variable of the new data section included in the object file 31. When a variable of the new data section is detected, bss_start which is a relative address at the head of the area where the variable is stored (distance from the head of the object program) and a relative address bss_at the end
and end. Then, the obtained relative address b
The ss_start and the bss_end are transferred to the initialization library 22a given earlier (for example,
Embed in place).

Subsequently, the linker 20b integrates the object files by a link process to generate the executable load module 32. Load module 32
Is executed, the OS 20 reads the load module 32 from the HDD 10d and places it in a predetermined area on the RAM 10c.

When the load module 32 is placed on the RAM 10c, first, the initialization library 22a is executed, and the relative addresses bss_start and bss_end are set.
From the start address (absolute address) of the load module expanded on the memory, the start address abss_start and the end address abss of the area to be initialized are obtained.
_End (absolute address). Then, for example, an initial value (“8B” in this example) specified when the program is executed is written into the area of the memory 33 specified by the calculated start address abss_start and end address abss_end. Will be.

According to the above processing, even for a dynamic variable whose storage position is undecided until it is arranged on the memory,
Since initialization processing with an arbitrary value becomes possible, it is possible to check for an undefined reference using a debug option.

Next, a flowchart for realizing the above-described processing will be described. FIG.
6 is a flowchart illustrating an example of a process performed by a. When this flowchart is started, the following processing is executed. [S1] The compiler 20a extracts a predetermined variable from a source file to be compiled. [S2] The compiler 20a determines whether the extracted variable is a dynamic variable. If the extracted variable is a dynamic variable, the process proceeds to step S3; otherwise, the process proceeds to step S4. [S3] The compiler 20a outputs an object code relating to the new data section. [S4] The compiler 20a outputs an object code related to the normal data section. [S5] The compiler 20a determines whether or not an unprocessed variable exists in the source file, and if so, returns to step S1 and repeats the same processing. Otherwise, proceeds to step S6. . [S6] The compiler 20a executes a compile process on a part other than the variable.

FIG. 6 is a flowchart illustrating an example of a process executed by the linker 20b. When this flowchart is started, the following processing is executed. [S20] The linker 20b executes a process of linking the initialization library 22a. [S21] The linker 20b uses another library (for example,
Execute the process of linking the mathematical function library. [S22] The linker 20b searches the object file for the object code associated with the new data section. [S23] The linker 20b determines whether or not the object code related to the new data section exists. If the object code exists, the process proceeds to step S24; otherwise, the process proceeds to step S27. [S24] The linker 20b acquires bss_start, which is the relative address at the head of the new data section. [S25] The linker 20b obtains bss_end, which is the relative address at the end of the new data section. [S26] The linker 20b obtains the relative address bs
s_start and bss_end are passed to the initialization library 22a.

Specifically, for example, these relative addresses are embedded in a predetermined area of the initialization library 22a. [S27] The linker 20b executes a link process.

Next, an example of the processing of the initialization library 22a will be described with reference to FIG. This processing is executed when the load module 32 is executed and arranged on the RAM 10c. [S40] The CPU 10a determines whether or not the values of the relative addresses bss_start and bss_end embedded in the load module 32 are the same. If the values are the same, the CPU 10a ends the process. Proceed to S41.

Here, if these values are the same, it means that the relative address is in a default state where no data is written. In this case, there is no dynamic variable to be initialized. And the process ends. [S41] For example, the CPU 10a acquires an initial value supplied from the input device 12 at the time of execution.

The initial value can be specified at the time of compiling and stored in a predetermined area of the load module, as described later. [S42] The CPU 10a sets the bss_start and bs
The initial value acquired in step S41 is arranged in the area on the RAM 10c specified by s_end.

According to the above processing, the processing described above can be realized. In the above example, a case has been described in which the number of data areas to be initialized is one. However, in the case of a plurality of data areas, this can be realized by repeating the above-described processing a required number of times.

Next, a more specific operation of the present embodiment will be described. First, a method of assigning a target variable to a new data section will be described with reference to FIG.

In the example of FIG. 8, on the second line of the source file 40, an array X1 and an array X2 are declared, and the same block name ALK is given. In the third line, an array X3 is declared, and a block name BLK is given.

When such a source file 40 is compiled, an object file 41 is generated. In this object file, for the arrays X1 and X2 to which the same block name is assigned,
The same data section is assigned. Also,
A data section different from the former two is assigned to the array X3.

In this example, the data section is allocated according to the block name. However, other various allocation methods are conceivable. For example, the method of allocating separate data sections by dividing the array and other variables, the method of allocating according to the number of elements in the array, and the data type (4 byte integer, 8 byte integer, 4 byte real number, 8 byte real number) There is a method of allocating according to a variable name, a method of allocating according to a variable name, and a method of allocating according to the name of a procedure.

The above example is an example of a method in which the compiler automatically allocates a data section. However, a programmer may directly specify the data section by a compile option or the like at the time of compilation.

In any case, by appropriately changing the assignment of the data sections, it becomes possible to initialize only desired variables with desired values. Next, with reference to FIG. 9, a description will be given of a process of integrating these variables when declarations regarding the same variables are scattered in the source file.

In the source file 50 shown in FIG. 9, the block name is B in the main program MAIN.
The array X3 of LK is declared. In the subroutine SUB, the same array (block name BL
K array X3) is declared.

When such a source file 50 is compiled by the compiler 20a, an object file 51 having object codes relating to the new data section in MAIN and SUB is obtained.

When such a link processing is performed on the object file 51 by the linker 20b, the object codes related to the new data section which existed separately in the MAIN and the SUB in the object file 51 are integrated into one. A combined link module 52 is generated.

Therefore, even if declarations relating to the same variable are scattered in the source file, these can be integrated into one variable. Next, FIG.
With reference to FIG. 0, a description will be given of a process of integrating these variables when declarations regarding the same variable exist in a plurality of source files.

In the example shown in FIG. 10, in the source file 60, the array X3 whose block name is BLK is MAIN.
In the source file 61, the same array X3 is declared in the SUB. Here, it is assumed that the source file 60 is compiled by a conventional compiler, and the source file 61 is compiled by the compiler 20a of the present embodiment.

As a result, in the object file 62, the conventional data section is allocated to the array X3, and in the object file 63, the array X3 is allocated.
3 is assigned a new data section.

When the two types of object files 62 and 63 are linked by the linker 20b, the linker 20b sets the object file 6
2, 63 are compared, and one is a new data section and the other is a normal data section, so that both are unified into a normal data section.

As a result, as shown in FIG. 10, a load module 64 in which both arrays X3 are allocated to a normal data section is obtained. As described above, when variables to which different data sections are assigned are integrated by link processing, the normal data section is prioritized, so that the same variable is prevented from being assigned to different areas, and the conventional data section is prevented from being assigned. A similar operation can be guaranteed.

In the above embodiment, the data is integrated into the normal data section. However, the data may be integrated into the new data section. In that case, the operation of the object file 62 compiled by the conventional compiler cannot be guaranteed, but the check for undefined references can be executed.

Next, a method of setting an initial value when a variable is initialized will be described. There are two methods for setting the initial value: (1) a method of specifying at the time of compiling and (2) a method of specifying at the time of execution. Below, first,
After describing the method (1), the method (2) will be described.

In the method (1), the initial value is specified by inputting the file name of the source file and the initial value following the start command of the compiler. For example, FIG.
When there are two types of new data sections with the block names ALK and BLK as in the example shown in
An example of the case where only “8B” is initialized is shown below. The file name of the source file is "abc.
f ”, and the activation command of the compiler is“ frt ”.

Frt abc. f−X (A) = 8B Here, “−” and following are compile options,
X (A) indicates that a new data section whose first character of the block name is A is to be initialized with an initial value “8B”.

When a compile option is specified by the command as described above and compilation is performed, an initial value “8B” is embedded in a predetermined area of the generated object file. At the time of execution, the initial values are read out, and the target variables (arrays X1 and X2 in this example) are initialized with the specified initial value “8B”.

Next, a method of specifying an initial value at the time of executing (2) will be described. Now, the file name of the load module is a. When the new data section with the block name BLK shown in FIG. 8 is initialized by the initial value “8B”, the load module is activated as follows.

A. out-X (B) = 8B By activating the load module in this way, it is possible to execute a program after initializing an arbitrary variable with an arbitrary initial value.

In the above example, the case of initialization using hexadecimal number "8B" has been described as an example. However, other than this, initialization may be performed using, for example, a not-a-number. The following is an example where the block name is BLK
Is an example in which a new data section is initialized by a not-a-number.

A. out-X (B) = R4NaN Here, R4NaN indicates that it is initialized by a 4-byte real number (R) not a number (NaN: Not a Number).

With the above processing, any variable can be initialized with an arbitrary initial value. If the initial value is specified at compile time and then at run time, the specification will be duplicated.
In such a case, either one may be preferentially adopted.

Next, an example will be described in which an undefined reference is checked using initialized variables. First, as the simplest method, a method will be described in which an instruction for printing out the contents of variables initialized in the source code is added and the contents of the variables are directly confirmed.

FIG. 11 shows an example of a source file to which an instruction to print out the contents of a variable has been added. In this example, an array X whose block name is BLK is defined in the second line from the top, and an instruction to print out the first content of the array X is added in the second line from the bottom. Note that “WRITE” is an output command, “6” in parentheses indicates the number of the output device (printer in this example), and (8Z) surrounded by single quotes indicates that the output is in hexadecimal. I have.

Such a program may be executed after compiling by designating the initial value “8B” as an option at the time of compiling, or may be executed at the time of execution.
If the value to be printed out is “8B8B8B8B” when the command is executed with “B” specified, it can be determined that the reference is undefined.

Next, a description will be given of an example of a case where the debugging options at the time of compiling are extended and used. Conventionally,
In FORTRAN, if the debug option "-Du" is specified at compile time, COMMON
Variables other than variables are initialized with the initial value “8B”, and when the variable to which this “8B” is assigned is referenced, the message “Undefined data was referenced.” Was displayed. .

By applying the present invention, the function of such a debug option "-Du" can be provided by COM.
It can be extended to MON variables. That is, when the debug option "-Du" is specified, CO
The MMON variable is also automatically initialized with an initial value “8B”, and “8B” when the variable is referred to.
If an error is detected, an error is notified,
The function of the debug option "-Du" can be extended to COMMON variables.

Next, ANSI (American National Stan)
dards Institute) / IEEE (Institute of Electric)
al and Electronics Engineers) A method of using a trap conforming to the 754 standard will be described.

In the conventional FORTRAN, an instruction for initializing a target variable by a non-numeral value is embedded in a program, and at the time of execution, the value of the variable is undefined by specifying an option "-trap". When it was referenced, the message "Invalid operation exception occurred." Was displayed. According to the present embodiment, such a trap can be performed only by specifying an option at the time of execution for a COMMON variable that is a dynamic variable.

In the following, as shown in FIG. 12, an array X whose block name is BLK is declared, and this array X is undefined and the source file 80 referred to in the second line from the end is copied. This will be described using an example.

The file name of the source file 80 is a. f, the following command is executed to convert the source file 80 into the compiler 20a.
Compile by

Frt a. Next, the obtained load module a. When executing out, the array X is initialized with a not-a-number and a trap option is specified as follows.

A. out-X = R4NaN-trap With the above specification, the array X is initialized and executed by a 4-byte not-a-number. In this case, when the second assignment statement from the bottom shown in FIG.
The second element is referenced, but if it is undefined, a not-a-number is assigned, so the trap option operates and the error message "Invalid operation exception has occurred" is displayed. Will be done.

Next, a case will be described where it is determined whether or not a subscript exceeding the declared range is used when referring to the contents of the array. For example, assume that there is a source file 90 shown in FIG. This source file 90
In the second line, the single-precision real type is used and the number of elements is 1
000 arrays A and B are declared.

When such an array is compiled,
Conventionally, the following object codes have been generated. . bss main. local, 8000 However, the compiler according to the present embodiment generates the following object code.

[0085] bss main. local, 800
8 That is, an object code is generated that secures an area 8 bytes larger than the required area. Here, 8008
FIG. 14 shows the breakdown of the bytes. As shown in FIG.
The first 4000 bytes of 008 bytes are allocated to array A, the next 4 bytes are redundant,
000 bytes are allocated for array B and the last 4
The bytes are redundant.

As described above, in the present embodiment, when an array is declared, a certain extra area is secured along with a necessary area, and the extra area is used as a redundant portion. The redundant portion secured in this way can be used to check whether a subscript exceeding the declared range has been used. That is, all the areas thus secured are initialized by, for example, a not-a-number, and if the trap option is specified at the time of execution, if the array is properly initialized, only Since a not-a-number is stored, if the message "Invalid operation exception has occurred" is displayed, it is highly likely that a subscript beyond the declared range was used. For example, FIG.
In the example shown in, the second DO loop (lines 6 to 8)
, The array subscript is used in the range of 1 to 1001, and when the subscript becomes 1001, the above-described error is output.

It is not clear from such a message alone whether the array subscript was used beyond the declared range or was due to an error other than that, but it is possible that the array subscript may be incorrect. It becomes possible to know. In the past, if an array subscript was used beyond the declared range, no indication was made, and it was difficult to even notice the presence of an error. Thus, it is possible to notice the possibility that an error is included.

By combining the above-described embodiment with the above-described method, it is possible to obtain an array that is a dynamic variable.
Inspection of array subscripts can be performed. Also, in such an embodiment, the conventional debugging options are used, so that the trouble of creating a new program is omitted, and by adding a new option, the entire processing can be performed by the amount of the processing. It is possible to prevent the speed from decreasing.

In the above embodiment, mainly the FOR
Although the description has been given by taking TRAN as an example, the present invention is also applicable to other languages, for example, C language and other languages.

In the above-described method of initializing a dynamic variable, the storage destination of the dynamic variable in the memory is passed to the initialization library as a relative address.
The present invention is not limited to only such a case. For example, when the load module is executed, a predetermined identification code is arranged before and after the area in the memory where the dynamic variable is stored, and the area surrounded by the identification code is set by the initialization library. It may be detected and initialized with a designated initial value. The point is that the initialization library may be notified of the area in the memory where the dynamic variables are stored.

Finally, the above processing functions can be realized by a computer. In that case, a program is provided that describes the processing content of the function that the information processing apparatus should have. By executing the program on a computer, the processing functions are realized on the computer. The program describing the processing content can be recorded on a computer-readable recording medium.
Computer-readable recording media include magnetic recording devices, optical disks, magneto-optical recording media, and semiconductor memories. Magnetic recording devices include a hard disk device (HDD) and a floppy (registered trademark) disk (F
D), magnetic tape and the like. The optical disk drive has D
VD (Digital Versatile Disc), CD-ROM (Compact
Disc Read Only Memory). Magneto-optical recording media include CD-R (Recordable) / RW (ReWritable), DV
D-RAM (Random Access Memory), MO (Magneto-Opt
ical disk).

When distributing a program, for example, a DVD or CD-ROM on which the program is recorded
And other portable recording media are sold. Alternatively, the program may be stored in a storage device of a server computer, and the program may be transferred from the server computer to another computer via a network.

The computer that executes the program stores, for example, the program recorded on a portable recording medium or the program transferred from the server computer in its own storage device. Then, the computer reads the program from its own storage device and executes processing according to the program. Note that the computer can also read the program directly from the portable recording medium and execute processing according to the program. Further, each time the program is transferred from the server computer, the computer may sequentially execute processing according to the received program.

[0094]

As described above, according to the present invention, in an information processing apparatus for translating a source file including a dynamic variable into an object file by a compiling process and converting it into an executable load module by a linking process, Identifies the dynamic variable specifying means that specifies the target dynamic variable from the, and specifies the area secured when the dynamic variable specified by the dynamic variable specifying means is expanded in memory when the load module is executed And an initializing unit for initializing the area specified by the area specifying unit with a predetermined initial value, so that an undefined reference of a dynamic variable can be inspected. Becomes

Further, according to the present invention, in an information processing apparatus which translates a source file including an array into an object file by a compiling process and converts the object file into an executable load module by a linking process, a target array is specified from the source file. An array specifying means for performing the load module execution, and an area reserving means for reserving an area larger than the area declared in the array specified by the array specifying means by a predetermined number of bytes when executing the load module. And initialization means for initializing an area secured by a predetermined initial value, so that it is possible to detect that a subscript exceeding a declared range is used in an array. .

[Brief description of the drawings]

FIG. 1 is a principle diagram for explaining the operation principle of the present invention.

FIG. 2 is a block diagram illustrating a configuration example of an embodiment of the present invention.

FIG. 3 shows an OS, a compiler, a linker, a source file,
FIG. 4 is a diagram illustrating a relationship between a library and an object file.

FIG. 4 is a diagram illustrating an outline of an operation of the exemplary embodiment of the present invention.

FIG. 5 is a flowchart illustrating an example of a process executed by the compiler illustrated in FIG. 3;

FIG. 6 is a flowchart illustrating an example of a process performed by the linker illustrated in FIG. 3;

FIG. 7 is a flowchart illustrating an example of a process performed by an initialization library illustrated in FIG. 4;

FIG. 8 is a diagram illustrating a method of assigning a target variable to a new data section.

FIG. 9 is a diagram illustrating a process of integrating variables when declarations related to the same variable are scattered in a source file.

FIG. 10 is a diagram illustrating a process of integrating variables when declarations regarding the same variable exist in a plurality of source files.

FIG. 11 is an example of a source file when checking for undefined references.

FIG. 12 is an example of a source file in a case where an undefined reference is inspected using a trap conforming to the ANSI / IEEE 754 standard.

FIG. 13 is an example of a source file for checking the use of array subscripts beyond a defined range.

FIG. 14 is a diagram showing an example of an array area secured in the present embodiment.

[Explanation of symbols]

 DESCRIPTION OF SYMBOLS 1 Source code 2 Dynamic variable specifying means 3 Area specifying means 4 Initializing means 5 Memory 10 Information processing device 10a CPU 10b ROM 10c RAM 10d HDD 10e GC 10f I / F 11 Display device 12 Input device 20 OS 20a Compiler 20b Linker 21 Source file 22 Library 23 Object file

 ──────────────────────────────────────────────────続 き Continued on the front page F-term (reference) 5B042 GA02 HH01 HH42 JJ43 JJ46 LA01 5B081 BB07 CC27 CC64

Claims (13)

[Claims] 1. An information processing apparatus for translating a source file including a dynamic variable into an object file by a compiling process and converting the object file into an executable load module by a linking process. Dynamic variable specifying means for specifying, and the dynamic variable specified by the dynamic variable specifying means,
Area specifying means for specifying an area to be secured when expanded on a memory at the time of execution of the load module; and initialization means for initializing the area specified by the area specifying means with a predetermined initial value. An information processing apparatus comprising: 2. A method according to claim 1, wherein when a plurality of different dynamic variables are specified by said dynamic variable specifying means, an area integrating means for integrating an area secured when being developed on said memory as necessary. The information processing apparatus according to claim 1, further comprising: 3. When one or more object files integrated by the link processing have the same dynamic variables scattered therein, the apparatus further comprises variable integration means for integrating these variables. The information processing device according to claim 1. 4. The dynamic variable specifying unit assigns a target dynamic variable to a new data section, and the initialization unit initializes only the dynamic variable assigned to the new data section as a target. The information processing apparatus according to claim 1, wherein the information processing apparatus executes a conversion process. 5. When the initialization module links the plurality of object files to generate the load module, the initialization means is assigned to the new data session for a predetermined object file, and the normal data for another object file. 5. The information processing apparatus according to claim 4, wherein when there is a dynamic variable assigned to the section, the initialization process is not performed on the dynamic variable. 6. The information processing apparatus according to claim 1, further comprising an initial value input unit for inputting an initial value by said initialization unit before a compiling process. 7. The information processing apparatus according to claim 1, further comprising initial value input means for inputting an initial value by said initialization means before execution of said load module. 8. The information processing apparatus according to claim 1, further comprising initialization variable designating means for designating a dynamic variable to be initialized. 9. The apparatus according to claim 1, further comprising an error notifying unit for notifying an error when the dynamic variable in which the initial value is set is referred to during execution of the load module. The information processing apparatus according to claim 1. 10. When the dynamic variable is an array,
The memory further includes a memory securing unit that secures a memory area larger by a predetermined amount than the number of elements of the array declared in the source code, wherein the initializing unit allocates all areas on the memory secured by the memory securing unit. 10. The information processing apparatus according to claim 9, wherein the information is initialized by a predetermined initial value, and the error notifying unit notifies an error when the array in which the initial value is set is referred to. 11. A computer-readable recording medium storing a program for causing a computer to execute a process of translating a source file including a dynamic variable into an object file by a compiling process and converting the source file to a load module in an executable format by a link process. In the computer, a dynamic variable specifying means for specifying a target dynamic variable from the source file, the dynamic variable specified by the dynamic variable specifying means,
An area specifying unit that specifies an area secured when being expanded on a memory when the load module is executed; and an initialization unit that initializes an area specified by the area specifying unit with a predetermined initial value. A computer-readable recording medium on which a program to be recorded is recorded. 12. A program for causing a computer to execute a process of translating a source file including a dynamic variable into an object file by a compile process and converting the source file including a dynamic variable into an executable load module by a link process. Dynamic variable specifying means for specifying a target dynamic variable, the dynamic variable specified by the dynamic variable specifying means,
An area specifying unit that specifies an area secured when being expanded on a memory when the load module is executed; and an initialization unit that initializes an area specified by the area specifying unit with a predetermined initial value. Program to let. 13. An information processing apparatus for translating a source file including an array into an object file by a compile process and converting the source file into an executable load module by a link process, wherein an array specification for specifying a target array from the source file is provided. Means, an area larger by a predetermined number of bytes than the area declared in the array specified by the array specifying means,
An information processing apparatus, comprising: an area securing unit that secures on a memory when the load module is executed; and an initialization unit that initializes an area secured by the area securing unit with a predetermined initial value. .