JP2002108628A - Program converter - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a program converter to convert a source program in which an object generating function including a dynamic area securing sentence consisting of a new operator, etc., to dynamically secure an area and to be substituted for a variable is described into a machine language program with high execution speed and a low execution cost. SOLUTION: When the dynamic area securing sentence exists in the object generating function, an object generating function converting part 103 adds a pointer type tentative argument to the object generating function and generates a static object generating function by replacing the dynamic area securing sentence with a substitution sentence for the variable of the pointer type tentative argument. An object generating sentence converting part 106, etc., create data of attributes to secure an area with the size to be secured by the dynamic area securing sentence when the size is calculated, translates the object generating sentence by converting an address of its data into a sentence to be provided to the static object generating function as an actual argument, and converts it into data of a ROM area arrangement attribute when all the member variables are calculated and remain unchanged in the case of translation.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a program conversion device for converting a source program into a machine language instruction sequence.
In particular, the present invention relates to a program conversion device for converting an object-oriented language source program including an object generation statement into a conversion target.

[0002]

2. Description of the Related Art In an object-oriented language, an object (instance) must be generated before use, and is generated by an object generation statement that calls an object generation function. Here, the object generation function is one of the member functions of the object, and is generally designed to include processing such as initial setting of the object. Note that the name of the object generation function includes information on the object name.

Hereinafter, a conventional program conversion apparatus for converting (translating) a source program described in an object-oriented language C ++ (hereinafter, referred to as "C ++ language") into a machine language program will be described. Here, the term of conversion is used to mean that a result such as a machine language program is generated based on a conversion target such as a source program, and does not mean that the conversion target itself is updated. .

FIG. 12 shows a definition of a class IntArray including an object generation function and a class IntArray.
FIG. 14 is a diagram illustrating a part of a source program in the C ++ language including an object generation statement for generating an object of y. In the C ++ language, an object generation function is called a constructor and is represented by a function having the same name as a class name. "IntArray (int siz
e) "is an object generation function of the class IntArray.

[0005] In this object generation function, "mem"
== new int [size]; ”is a statement that dynamically allocates a memory area for an array having the number of int-type variables indicated by size and substitutes the start address of the memory area into memp. It is. Hereinafter, the operator ne
A statement that dynamically allocates a memory area at the time of execution and assigns the start address of the memory area to a pointer-type variable, such as a statement including w, is called a dynamic area allocation statement. Although not shown in the figure, the class IntArray has a member function other than the object generation function that accesses the memory using the pointer-type member variable memp.

In the C ++ language, an object creation statement is described as an object declaration statement, and the object declaration statement “const IntArra” shown in FIG.
yArrayObj (10); "is the class IntArr
It has the meaning of generating the object “ArrayObj” of “ay”. In the declaration of this object, "Ar
“(10)” after “rayobj” is an actual argument to be passed to the object generation function.

[0007] Also, "const IntArray
ArrayObj (10) "at the beginning of the qualifier" cons
"t" indicates that the generated object is an object whose value does not change. Hereinafter, an object whose value does not change is referred to as a const object. Note that this object "Arrayobj" is
Since this is a global object that can be referenced from functions and other objects, it is always secured in memory before this source program is translated into machine language and started to be executed.

The program conversion device is a so-called compiler that translates a source program into a machine language, and generates a machine language program executable on a specific processor by referring to the source program. In the development of programs in the field of microcomputers for embedding in home electric appliances and the like, data in a source program should be allocated to data having attributes to be allocated to a RAM area or to a ROM area by a program conversion device. Each procedure in the source program is translated into data having the attribute, and is translated into a code having the attribute to be arranged in the ROM area.

Here, the RAM area refers to a readable / writable memory area, and the ROM area refers to a readable only memory area. The machine language program output by the program conversion device has codes and data arranged in a ROM area or a RAM area based on the respective arrangement attributes, and is executed on a specific processor under the control of an operating system (OS) or the like. Will be. That is, the code here is a machine language instruction sequence to be executed by the CPU, and the data is arranged in the memory before the OS executes the code.

A conventional program conversion device translates an object generation statement as shown in FIG. 12 into object data and a subroutine call instruction for calling an object generation function. Here, the object data refers to a set of member variables of the object. A conventional program conversion device generates the above-described subroutine call instruction as a code having an attribute to be arranged in a ROM area,
The object data is always generated as data having an attribute to be arranged in the RAM area.

[0011] The reason that such object data is always generated as data having an attribute to be arranged in the RAM area is that the operation of the object generation function executed when the object is generated causes the member variable of the object to be generated. This is because the value can be set dynamically. This means that the object created is const
It does not change even if it is an object.

FIG. 13 is a diagram showing a machine language instruction sequence as a result of translating the object generation sentence shown in FIG. 12 by the conventional program conversion device. This corresponds to a part of a machine language program generated by the conventional program conversion device based on the source program shown in FIG. In addition,
In the figure, the machine language is indicated by a mnemonic code for easy understanding.

Here, “.section RAMAR”
The portion between “EA” and “.section END” indicates attribute data to be arranged in the RAM area, and “Arrayobj: 8” indicates the object Arr
aobj represents a size of 8 bytes. Therefore, when the machine language program is executed, first, an 8-byte area is secured in the RAM area.

The portion between “.section TEXT” and “.section END” is R
Represents the code of the attribute to be placed in the OM area, "_I
“nitObj ()” indicates a function generated by the program conversion device as an object to be executed when generating an object, “mov & ArrayObj, R0” indicates a machine language instruction for storing the address of the object ArrayObj in the register R0, mov # 10, R1 "
Represents a machine language instruction for storing the actual argument 10 in the register R1, "call InitArray" represents a machine language instruction of a subroutine call for calling an object generation function, and ret represents a return instruction from the function. .

"IntArray ()" represents an object generation function, "movR0, R2" represents a machine language instruction for storing the head address of an object stored and passed in the register R0 in the register R2,
“ov R1, M (R2, 0)” indicates a machine language instruction that stores the value of the register R1 in the memory at the position of offset 0 from the address indicated by the register R2, and “lshift
“t R1, # 2, R0” indicates that the value of the register R1 is 2
A machine language instruction that stores the bit-shifted value in the register R0 is described as “call_memory_alloc_
"func" represents a machine language instruction of a subroutine call that calls a dynamic area securing function that dynamically secures an area of the size indicated by the contents of the register R0 at the time of execution and stores the start address of the area in the register R0 and returns "Mov R
“0, M (R2, 4)” represents a machine language instruction that stores the value of the register R0 as the memory content at the position of the offset 4 from the address indicated by the register R2, and ret represents a return instruction from the function. .

As described above, the conventional program conversion device translates an object generation statement in a source program into a code for calling an object generation function and object data having attributes to be arranged in a RAM area. Generally, if the code size of a machine language program is large, a large-capacity memory is required to execute this program, and the cost required for the execution increases.

Therefore, it is desirable that the code size of the machine language program be small from the viewpoint of cost. In the field of microcomputers for use in home electric appliances, the cost of RAM is higher than the cost of ROM.
In some cases, the cost may be more than four times M.

Therefore, as much data as possible is stored in RA
Making the attribute to be located in the ROM area instead of the M area leads to cost reduction. Therefore, a source program described in an object-oriented language is converted into a low-cost machine language program by reducing the code size of the machine language program or reducing attribute data to be arranged in the RAM area. Realization of a program conversion device is desired.

As a technique relating to a program conversion device for converting a source program into a machine language program having a low execution cost, there is a technique disclosed in Japanese Patent Application Laid-Open No. 2000-40005. This JP-A-2000-40
In the technique disclosed in Japanese Patent Application Publication No. 005, when an object generation statement is translated, a member variable value after calling an object generation function is calculated at a translation stage, and when it is determined that the member variable value becomes a constant, the constant is converted to a member variable. The object size is reduced and the code size is reduced by removing the call to the object generation function. Furthermore, when the member variable value is found to be a constant, the object value does not change in the object generation statement. If the object is declared, the RAM used by placing the object in the ROM area
This is a technology to reduce the area.

[0020]

However, the technique disclosed in the above publication is effective only when the member variable value immediately after the call to the object generation function can be calculated at the translation stage. It is not valid if a dynamic area allocation statement is included. Because, if the dynamic area allocation statement is included,
This is because the start address of the memory area secured by the execution of the dynamic area securing statement is substituted for the member variable value, but the address value cannot be specified at the translation stage.

Therefore, the present invention has been made in view of such a problem, and a program conversion apparatus for converting a source program in which an object generation function including a dynamic area reservation statement is described into a machine language program with low execution cost. The purpose is to provide. In general, since a program conversion device is required to generate a high-speed machine language program, the present invention provides, in addition to the above objects, a source program in which an object generation function including a dynamic area reservation statement is described. It is an object of the present invention to provide a program conversion device for converting a program into a machine language program with a high execution speed.

[0022]

In order to achieve the above object, a program conversion device according to the present invention secures a dynamic area and dynamically assigns a start address of the area to a pointer type variable. A program conversion device for converting a source program in which an object generation statement that generates an object by calling an object generation function including a statement into a machine language program, wherein the object generation function is called by the object generation statement Calculating means for calculating the size of the area secured by the dynamic area securing statement when assuming that
When the size of the area calculated by the calculation means is a constant value, the dynamic area securing statement is substituted for the first data of the size and the start address of the first data for the pointer type variable. A first conversion means for converting the object generation statement into an intermediate expression for performing the conversion, and an object generation function after the dynamic area reservation statement is converted by the first conversion means. And a second conversion unit for converting the に into a machine language instruction.

According to the above configuration, since the area to be secured by the dynamic area securing statement is placed as data in the machine language program, the subroutine call of the dynamic area securing function should not be performed. As a result, the program execution speed is improved. The data (first data) has an attribute that means that an area in the memory is secured by the OS before the machine language program is executed and the memory address of the data is determined. , The OS operates according to this attribute.
The memory address of the secured memory area is set as the head address of the data. Also, if the second conversion means is embodied using the conventional technique disclosed in Japanese Patent Application Laid-Open No. 2000-40005, the code size can be reduced.

Further, the program conversion device according to the present invention converts a source program including a plurality of dynamic area securing statements for dynamically securing an area and assigning the start address of the area to a pointer type variable into a machine language program. A program conversion device for performing conversion, comprising: size calculation means for calculating a size of an area to be secured by each of the plurality of dynamic area securing statements; and receiving a size as an argument and dynamically securing an area of the size. The dynamic area allocation routine, which is a subroutine for returning the start address of the area, is called by using the total value of the size of the area to be allocated by each of the dynamic area allocation statements as an argument. A dynamic area check that generates a subroutine call instruction to collectively secure all areas to be secured by the area securement statement A routine call instruction generating unit, and based on an address returned by execution of the subroutine call instruction and a size of each of the regions calculated by the size calculating unit, A start address calculating means for calculating a start address of each area corresponding to each of the plurality of dynamic area reservation statements; and A conversion unit for converting the start address of the area calculated by the address calculation unit into an instruction for substituting the start address into a corresponding pointer type variable.

According to the above configuration, the number of calls to the dynamic area securing routine, which generally has a relatively long execution time, can be reduced, so that the execution speed of the program resulting from the conversion is improved.

[0026]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS Hereinafter, a program conversion device according to an embodiment of the present invention will be described in detail with reference to the drawings. <Configuration> FIG. 1 is a functional configuration diagram of a program conversion device 100 according to an embodiment of the present invention.

The program conversion device 100 is configured to execute a program stored in a memory provided in a computer by using a CPU.
Is a so-called compiler that performs an operation of translating (converting) a source program into a machine language program by executing the program. Functionally, the control unit 102, the object generation function conversion unit 103, the dynamic area reservation statement detection unit 104,
It comprises a storage unit 105, an object generation sentence conversion unit 106, a dynamic reservation area calculation unit 107, an object generation function call translation unit 108, and a general sentence translation unit 109.

In a program stored in a memory provided in the computer, the control unit 102 corresponds to a main routine, and includes an object generation function conversion unit 103, a dynamic area reservation sentence detection unit 104, an object generation sentence conversion unit 106, The dynamic reservation area calculation unit 107, the object generation function call translation unit 108, and the general sentence translation unit 109 correspond to a subroutine.

FIG. 2 also shows an input file 101 and an output file 110 in addition to the program conversion device 100. Here, the input file 101 stores a source program described in an object-oriented language. The output file 110 stores a machine language instruction sequence generated as a result of the program conversion device 100 translating the input file 101.

The control unit 102 reads the source program from the input file 101 into the memory, sequentially pays attention to each sentence in the source program, and according to the type of the focused statement,
It has a function to distribute processing. That is, the control unit 102
Activates the object generation function conversion unit 103, the object generation sentence conversion unit 106, or the general sentence translation unit 109 according to the type of sentence of interest. Here, the term “attention” refers to processing a target, that is, specifying a location by a pointer or the like for processing.

The object generation function conversion unit 103 is activated by the control unit 102 when the definition of the object generation function in the source program is focused on, and a dynamic area securing statement is included in the definition of the object generation function. The dynamic area reservation statement detection unit 104 is activated to detect whether or not the statement exists, and if a dynamic area reservation statement is detected, a new static object generation function is generated and the static object generation function is executed. It has a function of storing in the storage unit 105 a pair with a target area securing statement.

Here, the static object generation function is
This is a function that is generated based on the original object creation function that included the dynamic area allocation statement. For the dummy argument of the static object creation function, a pointer-type dummy argument was added to the dummy argument of the original object creation function. For the processing contents of the static object creation function, the dynamic area allocation statement of the original object creation function is replaced by the newly added dummy argument in the pointer type member variable of the assignment destination in the dynamic area allocation statement. Is replaced by an assignment statement that assigns the value of

The dynamic area reservation statement detection unit 104 checks whether or not a dynamic area reservation statement exists in the definition of the object generation function. It has a function of notifying the conversion unit 103 and notifying that it does not exist. Storage unit 105
Is a specific area in the memory.

The object generation statement conversion unit 106 is activated by the control unit 102 when an object generation statement in a source program is focused on, and includes a static object generation function corresponding to the object class of the object generation statement. It is determined whether or not is already stored in the storage unit 105, and if it is stored, a dynamic area securing statement that is paired with the static object creation function is specified, and the dynamic area securing statement is Activate the dynamically allocated area calculation unit 107 to calculate the size of the area to be allocated, and if the size is a constant value, place the object generation statement in the RAM area using the constant value as the size and without specifying the initial value. Static object generation function call code that calls the attribute data to be performed and the start address of the RAM area as a pointer-type actual argument It converted into a de has the ability to launch object generation function calls the translation unit 108. If the size of the area to be secured by the dynamic area securing statement is found not to be a constant value as a result of the activation of the dynamic It has a function of converting the generated function call code and activating the object generation function call translator 108. Here, the static object generation function call code is an intermediate expression having a meaning of calling the static object generation function, that is, a code in a format for internal processing, and the object generation function call code is an intermediate expression having a meaning of calling the object generation function. It is.

The data of the attribute to be arranged in the RAM area or the data of the attribute to be arranged in the ROM area are stored when a machine language program including them is executed on a specific processor under the control of an OS or the like. In this case, the data is allocated to the memory before execution, and if an initial value is specified for these data, the initial value is stored in the memory.

The dynamic reservation area calculation unit 107 calculates the size of the area secured by the dynamic area reservation statement specified by the object generation statement conversion unit 106, and returns the size to the object generation statement conversion unit 106. If the value does not become a constant value, a notification that the size does not become a constant value is returned instead of returning the size. The object generation function call translation unit 108 is activated by the object generation statement conversion unit 106 and has a function of translating a static object generation function call code or an object generation function call code while referring to the object generation statement. That is, the initial value of each member variable of the object generated by these function call codes is calculated, and if the initial value of any member variable is a constant, if the object is a const object, the function The call code is translated into attribute data to be placed in a ROM area with the constant as an initial value, and if not a const object, the function call code should be placed in a RAM area with the constant as an initial value. Translate to attribute data. If the calculation result of the initial value of the object generated by the function call code is other than a constant, the data of the attribute which is the size of the object and should be arranged in the RAM area where the initial value is not specified, and the static object generation function or the It is translated into a subroutine call instruction sequence of a subroutine corresponding to the generation function.

If the definition of the function corresponding to the subroutine called by the subroutine call has not been translated, the function definition is translated. The object generation function call translating unit 108 outputs the translation result to the output file 1
Output to 10 The general sentence translator 109 includes the controller 102
, Which translates a sentence other than the object generation sentence into a machine language instruction sequence and outputs the output sentence to the output file 110. This general sentence translation process
This is a normal translation process used in a general program conversion device. <Data> FIG.
FIG. 3 is a diagram showing an example of data stored in a storage unit 105.

As shown in the figure, the storage unit 105 stores a set of a dynamic area securing statement and a definition of a static object generation function. Note that, for the sake of simplicity, the definition of the dynamic area allocation statement and the definition of the static object generation function are shown in FIG.
Although described in the + language, the program converter 100 actually reads the source program from the input file 101 into the memory, converts it into an intermediate representation, and performs a translation process, like a general program converter. According to this, the definition of the static object generation function is also generated in the form of an intermediate representation.

"_IntArray_s" shown in the example of FIG.
static ", the static object generation function
“Mem = new int [siz] shown in FIG.
e]; ”, the object generation function conversion unit 10 based on the object generation function“ IntArray ”including the dynamic area reservation statement.
3 is generated.

This "_IntArray_stati"
The formal parameter of the static object generation function “c” is “I
"int size" which is a dummy argument of "ntArray"
And a newly added “void * area”. Also, “mep =” in the static object generation function
The statement “area;” is “new int [size]” in the dynamic area reservation statement in “IntArray”.
Is replaced with “area” which is the content of the dummy argument. <Operation> The operation of the program conversion device 100 having the above-described configuration will be described below.

Here, it is assumed that the C ++ language source program shown in FIG. 12 is stored in the input file 101, and an example in which the program conversion apparatus 100 converts the source program will be described. FIG. 3 is a flowchart showing the overall operation of the program conversion device 100.

First, the control unit 102 of the program conversion apparatus 100 reads a source program stored in the input file 101, and focuses on one sentence in the program (step S301). Note that one sentence includes the definition of the object generation function. Subsequently, the control unit 1
02 determines whether or not the sentence of interest is the definition of an object generation function (step S302). If the statement is an object generation function definition, the object generation function conversion unit receives the object generation function definition as an input. 10
3 is started to perform an object generation function conversion process (step S303). The object generation function conversion process is a process of generating a static object generation function under certain conditions, and the details will be described later.

Here, the sentence of interest is class IntAr
object creation function “IntArray (i
nt size) ", an object generation function conversion process is performed. If the focused statement is not the definition of the object generation function, the control unit 102
Determines whether the focused statement is an object generation statement (step S305), and if the statement is an object generation statement, activates the object generation statement conversion unit 106 with the object generation statement as an input to generate an object generation statement. A sentence conversion process is performed (step S30)
6). The object generation statement conversion process is a process of temporarily converting an object generation statement into a static object generation function call code or an object generation function call code, and translating a function call code that is a result of the conversion. It will be described later.

Here, the sentence of interest is the class IntAr
ray object creation statement "const IntAr
If “ray ArrayObj (10);”, the object generation sentence conversion process is performed. Also,
If the sentence of interest in step S305 is not an object generation sentence, the sentence is input and the general sentence translating unit 109 is activated to perform a general sentence translation process (step S307).

Object generation function conversion processing (step S303), object generation sentence conversion processing (step S303)
306) or after the general sentence translation process (step S307) ends, the control unit 102 determines whether or not there is a sentence that has not yet been focused on (step S304), and if so, returns to step S301 and returns to the next sentence. Attention is paid, and if not, the operation is terminated.

Hereinafter, the object generation function conversion processing will be described. FIG. 4 is a flowchart illustrating an object generation function conversion process mainly performed by the object generation function conversion unit 103. When the object generation function conversion unit 103 is activated by the control unit 102 with the definition of the object generation function as an input, the dynamic area reservation statement detection unit 104 determines whether the dynamic area reservation statement is included in the definition of the object generation function. Is detected (step S401).

When the object generation function conversion unit 103 receives a notification from the dynamic area reservation statement detection unit 104 that there is no dynamic area reservation statement, it ends the object generation function conversion process (step S402). When the dynamic area allocation statement is detected by the dynamic area allocation statement detection unit 104, the object generation function conversion unit 103 copies the definition of the input object generation function, changes only the name, and newly creates a new object. A definition of a generation function is generated (step S403). Name changes shall follow a predetermined naming rule. This naming convention is, for example, to add "_" before the name of the original object creation function and "_stat" after it.
ic ”.

In the example shown in FIG. 12, "IntArra
The definition of “y (int size)” is input, and a dynamic area reservation statement “mep = new int [size];” exists in this definition. Therefore, the object generation function conversion unit 103 sets “_IntArray_stati”.
c (int size) "is generated. Subsequent to step S403, the object generation function conversion unit 103
Adds a pointer-type dummy argument as a dummy argument of the generated object generation function (step S404). The dummy argument name is determined according to a predetermined rule.
rea ”.

After adding the pointer-type dummy argument, the object generation function conversion unit 103 replaces the right side of the dynamic area reservation statement included in the definition of the newly generated object generation function with the added dummy argument (step S101). S40
5). As a result, the definition of the static object generation function is generated. Subsequent to step S405, the object generation function conversion unit 103 stores the detected dynamic area allocation statement and the generated definition of the static object generation function in the storage unit 105 as a pair, and performs the object generation function conversion processing. Is completed (step S406).

As a result, the data shown in FIG. 2 is stored in the storage unit 105. Hereinafter, the object generation sentence conversion process will be described. FIG. 5 is a flowchart showing the object generation sentence conversion process. When the object generation statement conversion unit 106 is activated with the object generation statement as an input, the definition of the static object generation function corresponding to the object generation function called by the object generation statement has already been generated and stored in the storage unit 105. It is determined whether or not there is (step S501).
Object creation statement "const IntArray
When "ArrayObj (10);" is input, the object generation sentence conversion unit 106 sets the class name "IntArray
y ”and the corresponding static object generation function name is“ _IntArray_stati ”according to a predetermined naming rule.
c ", and the function name is used as a key to search the storage unit 105.

If the definition of the static object generation function corresponding to the object generation statement has already been stored in the storage unit 105, the object generation statement conversion unit 106 activates the dynamic reservation area calculation unit 107, and (Step S50)
2). When the size of the area secured by the dynamic area securing statement is represented by a dummy argument to the object creation function, the dynamic secured area calculation unit 107 The size is calculated using the value.

Here, "ne" on the right side of the dynamic area allocation statement
The size of the area secured by “w int (size)” is such that the actual argument value corresponding to the dummy argument “size” is “10”.
Therefore, 40 is calculated by multiplying the int type 4 bytes by 10. The object generation sentence conversion unit 106 determines whether the size calculation result in step S502 is a constant (step S50).
3) If it is a constant, the data of the attribute to be arranged in the RAM area without the initial value of the calculated size is generated (step S504), and the object generation statement is
The head address of the data generated in step S504 is converted into a static object generation function call code in which an actual argument is used (step S505).

Here, “_area00” is set in step S504 corresponding to the object generation statement shown in FIG.
Is generated, the attribute data to be arranged in the 40-byte RAM area that can be identified by the name
"_IntArra" including the start address in the actual argument
y_static (10, &_area00);"is generated.

The object generation sentence conversion unit 106
Is when it is determined in step S501 that the definition of the static object generation function corresponding to the object generation statement has not been generated, or when it is determined in step S503 that the size of the area allocated by the dynamic area allocation statement is not a constant. , The object generation statement is simply converted into an object generation function call code (step S
506). For example, if IntArray is an object creation function that does not include a dynamic area allocation statement,
An object generation function call code "IntArray (10);" is generated.

If it is determined in step S503 that the size of the area to be secured by the dynamic area securing statement is not a constant, for example, the variable used as the basis for calculating the size of the secured area may be a value such as an input value from the user. The return value may be a return value of an input / output routine provided by the OS. The object generation sentence conversion unit 106 activates the object generation function call translation unit 108 with the generated static object generation function call code as an input after the execution of step S505, and generates the generated object after the execution of step S506. Object generation function call translator 10 with function call code as input
8 to activate the function call code translation process (step S507), and ends the object generation sentence conversion process.

The function call code translation process will be described below. FIG. 6 is a flowchart showing a function call code translation process performed by the object generation function call translation unit 108. When the object generation function call translating unit 108 is activated by inputting the static object generation function call code or the object generation function call code from the object generation sentence conversion unit 106, the definition of the object generation function and the actual Based on the arguments, the initial value of each member variable of the object to be generated corresponding to the object generation function is calculated (step S601), and whether or not the initial values of all the member variables are constants Is determined (step S602). That is, it is determined whether the value of the member variable can be calculated at compile time without actually operating the program. In order to realize the processing shown in steps S601 and S602, a conventional technique disclosed in Japanese Patent Application Laid-Open No. 2000-40005 may be used.

If it is determined in step S602 that the object is a constant, the object generation function call translating unit 108 determines whether the object is a const object whose value does not change at execution time.
nst ”(step S
603) If the object is a const object, the input function call code is stored in the ROM using the constant as an initial value.
The data is translated into the data of the attribute to be arranged in the area (step S604), and the function call code translation process ends. If it is determined in step S603 that the object is not a const object, the object generation function call translator 108 converts the input function call code into
It is translated into attribute data to be arranged in the RAM area of the initial value calculated in step S601 (step S60).
5) End the function call code translation process. Note that the translation result is output to the output file 110.

If it is determined in step S602 that the initial value of at least one member variable is not a constant, that is, the actual argument of the input function call code and the definition of the object generation function called by the function call code If the member variable cannot be specified as a constant value by the calculation based on the attribute value, the object generation function call translating unit 108 stores the data of the attribute to be arranged in the RAM area having the size corresponding to all the member variables and not specifying the initial value. Is generated (step S606), the input function call is translated into a subroutine call instruction sequence of the object generation function (step S607), and the function call code translation process ends.

"_IntArray_static (1
0, &_area00);", the object generation function call translator 108 converts the member variable“ length ”of the object shown in FIG.
And the initial values of “mem” are replaced with the assignment statements “length = size;” and “mem = area;” included in the definition of the static object generation function, the actual arguments “10” of the static object generation function call code, and "&
_Area00 ”and“ 10 ”,“ & _a ”respectively.
area00 ", and"& _area00 "is determined as the address value of the RAM area before the execution of the program. Therefore, it is determined that the initial value of the member variable is a constant. In this case, the original object creation statement is "cons
t ”, the step S
604 is executed, and as a translation result, object data of the attribute to be arranged in the ROM area is obtained.

In this way, the source program shown in FIG. 12 is translated into the machine language instruction sequence shown in FIG. <Consideration> FIG. 7 is a diagram showing a translation result of the source program shown in FIG.

As a result, the object generation statement in the source program is converted into the machine language instruction sequence shown in FIG. In the figure, ".section RAMARE"
A section between “.A” and “.section END” indicates attribute data to be arranged in the RAM area,
“_Area00: 40” indicates that the data area identified by the name of _area00 is 40 bytes in size.

In addition, ".section ROMARE"
A portion between “.A” and “.section END” indicates attribute data to be arranged in the ROM area,
"ArrayObj 10: 4, & _area00:
"4" indicates that 4-byte immediate data 10 and 4-byte immediate address & _area00 are stored in the ROM area as the initial values of the object ArrayObj.

The program conversion device 100 shown in FIG.
13 is compared with the translation result obtained by the conventional program conversion device shown in FIG. 13, the program conversion device 100 does not generate a machine language instruction sequence corresponding to the object generation function, and thus the code It is clear that the size has been reduced and memory_
Since a subroutine call for calling a dynamic area securing function called "alloc_func" is not generated, the execution speed of the program is improved.

Further, according to the program conversion apparatus 100, the ArrayObj is not the RAM area but the data of the attribute to be arranged in the ROM area. Therefore, the RAM area necessary for executing the generated program is also reduced. . <Supplement> Although the program conversion apparatus according to the present invention has been described based on the embodiment, it is needless to say that the present invention is not limited to this embodiment. That is, (1) In the present embodiment, the program conversion device is C +
The source program described in the + language is a translation target, but the present invention is not limited to this. A source program written in another object-oriented language may be the translation target. (2) In the present embodiment, the definition of the static object generation function is stored in the storage unit 105 as a pair with the dynamic area reservation statement. It may be stored in association with the function definition.

The processing procedure of the program conversion device is as follows.
The present invention is not limited to the procedure shown in the flowchart. That is, a dynamic area allocation statement exists in the definition of the object generation function of the source program, and the size of the area allocated by the dynamic area allocation statement is calculated as a fixed value at compilation based on the contents of the source program. Is completed, the dynamic area allocation statement is converted into attribute data to be allocated in the RAM area of the calculated size,
Any procedure may be used as long as the head address of the data is converted into an intermediate expression to be assigned to a member variable whose address is to be assigned by the dynamic area reservation statement. This eliminates the need for a subroutine call of the dynamic area securing function where the execution time is relatively long, so that the execution speed of the program can be improved. Furthermore, as a result, if all the member variables of the object can be calculated as fixed values at the time of compilation, the values of all the member variables can be calculated without generating a code such as a subroutine call of the object generation function. Any procedure can be used as long as the attribute data to be arranged in the RAM area or the ROM area having a certain fixed value as an initial value is the translation result of the object generation sentence. This further improves execution speed and reduces code size. The intermediate expression is
The description format at the source program level may be used. (3) Program conversion device 100 described in the present embodiment
If the size of the area allocated by the dynamic area allocation statement cannot be calculated as a fixed value at compile time, the same operation as the conventional program change device will be performed, and the translated program Is _mem in the machine language subroutine corresponding to the object creation function.
This calls a dynamic area securing function called ory_alloc_func. However, even if the size of the area secured by the dynamic area securing statement cannot be calculated as a fixed value at compile time, if it can be calculated as a fixed value before executing the machine language instruction sequence corresponding to the object creation statement, Calling the dynamic area allocation function from the machine language subroutine corresponding to the object generation function by using the method of giving the head address of the allocation area as an argument to the machine language subroutine corresponding to the object generation function as shown in the embodiment Can be deleted. With this method, it is possible to reduce the number of calls to the dynamic area securing function and shorten the execution time when a plurality of object generation statements of the same class are described in the source program. less than,
This method will be described.

FIG. 8 shows the definition of the same class IntArray as that shown in FIG.
FIG. 11 is a diagram illustrating a part of a source program in the C ++ language including two object generation statements for generating an object of ay. In FIG. 8, getsize is a function for acquiring the size of a specific element in the program execution environment according to the number passed as an argument.

Therefore, the initial value of the member variable length for the object ArrayObj1 is
The size obtained as the execution result of getsize (1) is the size, and the initial value of the member variable memp is
This is the start address of the area with the size indicated by th. The initial value of the member variable length for the object ArrayObj2 is the size acquired as a result of executing getsize (2), and the initial value of the member variable memp is
This is the start address of the area where the size indicated by ngth is secured.

FIG. 9 is a diagram showing a conventional program conversion apparatus according to FIG.
FIG. 13 is a diagram showing a machine language instruction sequence as a result of translating the object generation sentence shown in FIG. In the machine language instruction sequence shown in FIG. 9, IntArray, which is a subroutine corresponding to an object generation function, is called twice in order to generate two objects, ArrayObj1 and ArrayObj2, in _InitObj, and _memory_alloc_
func has been called. Therefore, when this program is executed, _memory_alloc_fun
The dynamic area securing function c is executed twice.

On the other hand, a translation result by the program conversion apparatus according to the present invention using the method of giving the head address of the secured area as an argument to the machine language subroutine corresponding to the object generation function is shown below. FIG. 10 is a diagram showing a machine language instruction sequence as a result of translating the object generation sentence shown in FIG. 8 using the method of the present invention.

In the machine language instruction sequence shown in FIG. 10, as a subroutine corresponding to an object generation function, a pointer type pointer to a normal IntArray is used in the same manner as the static object generation function in the above embodiment. There is _IntArray_static, which adds an argument and substitutes the argument for a member variable. Also, in _InitObj, _memory_al
loc_func is called once, _IntArra
y_static has been called twice.

The contents of the machine language instruction sequence shown in FIG. 10 are simply shown in FIG. 11 using a high-level language notation. Hereinafter, description will be made with reference to FIG. "S1 = getsiz
e (1); "and" s2 = getsize (2); "
It is generated based on the getsize described as the actual argument of each of the two object generation statements shown in FIG. When these are executed, the respective sizes obtained by getsize are substituted for s1 and s2.

"Areatop = _memory_al
loc_func ((s1 + s2) * 4); "is s1
And an int type area corresponding to the sum of the size indicated by s2 and the size indicated by s2,
This is to be assigned to "etop". Rather than securing the area twice as in the related art, the area having the total size of twice is secured once.

"_IntArray_static (&
ArrayObj1, s1, areatop);
In order to set the member variables of the ArrayObj1 object, s1 indicating the size and areatop, which is the start address of the reserved area, are passed to a subroutine corresponding to an object generation function. "_IntA
array_static (& ArrayObj2, s
2, areatop + (s1 * 4));
To set a member variable of the yObj2 object,
The size s2 and the top address of the ArrayObj2 area, areatop + (s1 * 4), of the area secured once are passed to the subroutine corresponding to the object generation function.

As described above, by combining a plurality of dynamic area allocation statements into one, it is possible to reduce the number of calls to library functions or system calls for dynamically allocating an area at once, and to reduce the execution time. Can be achieved. (4) In the present embodiment, the data of the attribute to be allocated in the RAM area corresponding to the dynamic area allocation statement is generated without calculating the initial value of the area allocated by the dynamic area allocation statement. Although the method was used, the initial value of the area allocated by the dynamic area allocation statement is calculated in the same way as the calculation of the initial value of the member variable of the object, and it is determined whether the area is a constant. Is a constant and it is known that the contents of the area are not changed at the time of execution, the data may be translated into attribute data to be arranged in the ROM area. As a result, data stored in the area secured by the dynamic area securing statement can also be previously stored in the ROM area, so that the RAM area required for executing the program can be further reduced. (5) In the present embodiment, the case where there is one dynamic area reservation statement has been described. However, even if there are a plurality of dynamic area reservation statements, the number of pointer-type dummy arguments is increased by the number of dynamic area reservation statements. , Generate a static object generation function by replacing the dynamic area allocation statement with a statement that assigns a pointer-type dummy argument to a member variable. What is necessary is just to call the static object generation function using each head address as an actual argument. (6) Although not specifically shown in the present embodiment, the area secured by the dynamic area securing statement and the area for storing the member variables of the object are both attribute data to be arranged in the ROM area. In such a case, or when both of them become attribute data to be arranged in the RAM area, these data may be attributed to be allocated to the adjacent memory area. That is, the relative address of each data may be designated and set so as to be located at a continuous address. In this case, the areas accessed by the member functions of the object are adjacent to each other, and depending on the hardware architecture and the specifications of the OS, the reference can be performed at a higher speed than when the two areas are separated from each other. As a result, the program execution speed is improved. (7) In the present embodiment, the data generated corresponding to the dynamic area reservation statement is data of the attribute to be arranged in the RAM area where no initial value is specified, but an arbitrary initial value is specified. You can do it. (8) In the embodiment, a computer program for causing a general-purpose computer to execute the processing procedure of the program conversion device shown in FIGS. 3 to 6 is recorded on a recording medium or through various communication paths and the like. They can also be distributed and distributed.

Such recording media includes an IC card, an optical disk, a flexible disk, a ROM, and the like. Distribution,
The distributed computer program is used by being installed on a general-purpose computer or the like,
The general-purpose computer executes the computer program to realize the program conversion device as described in the present embodiment.

[0076]

As is apparent from the above description, the program conversion apparatus according to the present invention provides an object including a dynamic area securing statement for dynamically securing an area and assigning the start address of the area to a pointer type variable. A program conversion device that converts a source program in which an object generation statement for generating an object by calling a generation function is described into a machine language program, assuming that the object generation function is called by the object generation statement Calculating means for calculating the size of the area secured by the dynamic area securing statement, and, if the size of the area calculated by the calculating means is a constant value, To assign the first data of the size and the start address of the first data to the pointer type variable A first conversion unit for converting the object generation statement into an intermediate representation; and an object generation function obtained by converting the dynamic area securing statement by the first conversion unit. And a second conversion unit that converts the instruction into an instruction.

As a result, the area to be secured by the dynamic area securing statement is placed as data in the machine language program. Program execution speed is improved. Also, if the second conversion means is embodied using the conventional technique disclosed in Japanese Patent Application Laid-Open No. 2000-40005, the code size can be reduced.

Further, the second conversion means sets the member variables of the object by the call when the object generation function after conversion by the first conversion means is called by the object generation statement. When the value is a constant value, the object generation statement is converted to second data having the same size as the object member variable, which is data having an address value or a constant value set in the member variable, If the object generated by the object generation statement is an object whose value does not change, the second data
The data may be attribute data to be arranged in the OM area.

Thus, the object generation statement is translated into object data (that is, the second data) in a state that will be after calling the object generation function, and if the object generation statement has a const qualifier, Since an attribute to be arranged in the ROM area is given to the object data, the code corresponding to the object generation function can be reduced, and the RAM area required at the time of execution can be reduced. In a microcomputer for embedded use, a RAM is generally higher in cost than a ROM, so that the cost can be reduced.

Further, the second conversion means is set for the first data by the call when it is assumed that the object generation function converted by the first conversion means is called by the object generation statement. When the value is a constant value, the constant value is set as an initial value of the first data, and if the first data does not change from the initial value, the first data is an attribute to be arranged in the ROM area. May be used.

As a result, the area to be reserved by the dynamic area reservation statement can be
Since the data of the attribute to be arranged in the area is stored in the machine language program, the cost can be reduced. Further, the first conversion means adds a pointer-type dummy argument based on the object generation function including the dynamic area allocation statement, further stores the dynamic area allocation statement in the pointer type variable, and Generating a static object generation function which is an intermediate expression replaced with an assignment statement to be substituted, wherein the second conversion means converts the object generation statement into
The head address of the first data is passed so that it can be used as the formal parameter of the pointer type, and is converted into an intermediate expression for calling the static object generation function generated by the first conversion means. A corresponding machine language instruction may be generated.

Thus, the processing structure of the program conversion device for removing the dynamic area reservation statement from the object generation function can be made relatively simple. Also,
The first data and data corresponding to a member variable of the object may be data of an attribute assigned to an adjacent memory area. As a result, the program execution speed is improved depending on the hardware architecture or the OS specifications that are the operating environment of the machine language program.

Further, the program conversion device according to the present invention converts a source program including a plurality of dynamic area securing statements for dynamically securing an area and substituting the start address of the area into a pointer type variable into a machine language program. A program conversion device for performing conversion, comprising: size calculation means for calculating a size of an area to be secured by each of the plurality of dynamic area securing statements; and receiving a size as an argument and dynamically securing an area of the size. The dynamic area allocation routine, which is a subroutine for returning the start address of the area, is called by using the total value of the size of the area to be allocated by each of the dynamic area allocation statements as an argument. A dynamic area check that generates a subroutine call instruction to collectively secure all areas to be secured by the area securement statement A routine call instruction generating unit, and based on an address returned by execution of the subroutine call instruction and a size of each of the regions calculated by the size calculating unit, A start address calculating means for calculating a start address of each area corresponding to each of the plurality of dynamic area reservation statements; and A conversion unit for converting the start address of the area calculated by the address calculation unit into an instruction for substituting the start address into a corresponding pointer type variable.

As a result, the number of times of calling the dynamic area securing routine, which generally has a relatively long execution time, can be reduced, so that the execution speed of the program resulting from the conversion is improved.

[Brief description of the drawings]

FIG. 1 is a functional configuration diagram of a program conversion device 100 according to an embodiment of the present invention.

FIG. 2 shows a storage unit 1 in which an object generation function conversion unit 103 is used.
FIG. 5 is a diagram showing an example of the content of data stored in a storage unit 05.

FIG. 3 is a flowchart showing an overall operation of the program conversion device 100.

FIG. 4 is a flowchart illustrating an object generation function conversion process mainly performed by an object generation function conversion unit 103;

FIG. 5 is a flowchart illustrating an object generation sentence conversion process.

FIG. 6 is a flowchart showing a function call code translation process performed by an object generation function call translation unit 108;

7 is a diagram showing a translation result of the source program shown in FIG. 12 by the program conversion device 100. FIG.

FIG. 8 shows the same class IntArra as shown in FIG.
C + containing the definition of y and two object creation statements that create new objects of class IntArray
FIG. 9 is a diagram showing a part of a + language source program.

9 is a diagram showing a machine language instruction sequence as a result of translating the object generation sentence shown in FIG. 8 by the conventional program conversion device.

FIG. 10 is a diagram showing a machine language instruction sequence as a result of translating the object generation sentence shown in FIG. 8 using the method of the present invention.

11 is a diagram simply showing the contents of the machine language instruction sequence shown in FIG. 10 using a notation at a high-level language level.

FIG. 12 shows a class IntA including an object generation function.
FIG. 14 is a diagram illustrating a part of a source program in the C ++ language including a definition of “rray” and an object generation statement for generating an object of class IntArray.

13 is a diagram showing a machine language instruction sequence as a result of translating the object generation sentence shown in FIG. 12 by the conventional program conversion device.

[Explanation of symbols]

 REFERENCE SIGNS LIST 100 program conversion device 101 input file 102 control unit 103 object generation function conversion unit 104 dynamic area reservation sentence detection unit 105 storage unit 106 object generation statement conversion unit 107 dynamic reservation area calculation unit 108 object generation function call translation unit 109 general sentence Translator 110 output file

Claims (8)

[Claims] 1. An object generation statement for generating an object by calling an object generation function including a dynamic area reservation statement for dynamically allocating an area and assigning the start address of the area to a pointer variable. A program conversion device for converting a source program into a machine language program, wherein the size of an area secured by the dynamic area securing statement is calculated when it is assumed that the object creation function is called by the object creation statement. Calculating means, when the size of the area calculated by the calculating means is a constant value, the dynamic area securing statement is set to the first data of the size and the start address of the first data to the pointer. First conversion means for converting the data into an intermediate representation for substituting into a type variable; And a second conversion unit for converting the object generation statement into a machine language instruction as a function to be called by the object generation statement after the object area securing statement has been converted. . 2. The method according to claim 1, wherein the second conversion unit is configured to set a member variable of the object by the call when the object generation function after conversion by the first conversion unit is called by the object generation statement. When the value is a constant value, the object generation statement is converted to second data having the same size as the object member variable, which is data having an address value or a constant value set in the member variable, If the object generated by the object generation statement is an object whose value does not change, the second data is stored in the ROM.
2. The program conversion device according to claim 1, wherein the data is attribute data to be arranged in the area. 3. The second conversion means is set for the first data by the call when it is assumed that the object generation function converted by the first conversion means is called by the object generation statement. When the value is a constant value, the constant value is set as an initial value of the first data, and if the first data does not change from the initial value, the first data is an attribute to be arranged in the ROM area. 2. The data of claim 1,
Or the program conversion device according to 2. 4. The first conversion means adds a pointer-type dummy argument based on an object generation function including the dynamic area reservation statement, and further adds the dynamic area reservation statement to the pointer type variable. Generating a static object generation function which is an intermediate expression replaced with an assignment statement for substituting a dummy argument, wherein the second conversion means converts the object generation statement into a pointer type of a first address of the first data. The static object generation function generated by the first conversion means is converted into an intermediate expression for calling the static object generation function, and a machine language instruction corresponding to the intermediate expression is generated. The program conversion device according to claim 1. 5. The method according to claim 1, wherein the first data and data corresponding to a member variable of the object are data of an attribute assigned to an adjacent memory area. The program conversion device according to the above. 6. A program conversion apparatus for converting a source program including a plurality of dynamic area securing statements for dynamically securing an area and assigning a start address of the area to a pointer type variable into a machine language program, Size calculating means for calculating the size of an area to be secured by each of the plurality of dynamic area securing statements, and a subroutine for receiving a size as an argument, dynamically securing an area of the size, and returning a start address of the area Is called as an argument with the total size of the areas to be secured by each of the plurality of dynamic area securing statements, so that all the A dynamic area securing routine call instruction generating means for generating a subroutine call instruction for collectively securing the area of Based on the address returned by the execution of the routine call instruction and the size of each of the areas calculated by the size calculation means, each of the plurality of dynamic area allocation statements among the areas allocated by the dynamic area allocation routine A start address calculating means for calculating a start address of each area corresponding to the above-mentioned area; and an area calculated by the start address calculating means corresponding to each of the plurality of dynamic area securing statements corresponding to the dynamic area securing statement. Converting means for converting the start address of the instruction into an instruction for substituting the pointer address into a corresponding pointer type variable. 7. An object generation statement for generating an object by calling an object generation function including a dynamic area reservation statement for dynamically allocating an area and assigning the start address of the area to a pointer type variable. A recording medium storing a control program for causing a computer to execute a program conversion process of converting a source program into a machine language program, wherein the program conversion process includes a step of calling the object generation function by the object generation statement. A calculating step of calculating a size of an area secured by the dynamic area securing statement in a case where it is assumed; and a dynamic area securing statement when the size of the area calculated by the calculating step is a constant value. With the data of the size and the start address of the data. First conversion to intermediate representation for assignment to pointer type variable
A conversion step; and a second conversion step of converting the object generation statement into a machine language instruction, assuming that the object generation function calls the object generation function after the dynamic area securing statement has been converted by the first conversion step. And a recording medium comprising: 8. A program conversion process for converting a source program including a plurality of dynamic area allocation statements for dynamically allocating an area and assigning the start address of the area to a pointer type variable into a machine language program, by a computer. A recording medium on which a control program to be executed is recorded, wherein the program conversion processing includes: a size calculating step of calculating a size of an area to be secured by each of the plurality of dynamic area securing statements; The dynamic area allocation routine, which is a subroutine for dynamically allocating an area of the size and returning the start address of the area, is executed by summing the size of the area to be allocated by each of the plurality of dynamic area allocation statements. By calling all the areas to be secured by the dynamic area securing statements. Generating a subroutine call instruction for generating a subroutine call instruction for securing the subroutine call instruction, based on an address returned by execution of the subroutine call instruction and the size of each area calculated in the size calculation step. A start address calculating step of calculating a start address of each area corresponding to each of the plurality of dynamic area securing statements among the areas secured by the dynamic area securing routine; A conversion step of converting each of them into an instruction for assigning the start address of the area calculated in the start address calculation step to the corresponding pointer type variable in accordance with the dynamic area reservation statement. Medium.