JP2005085051A - Software converter - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To provide a software converter capable of generating a source code according to a grammar of a high-level language. <P>SOLUTION: A label detection means 102 detects a head label and a label that is an argument of a call sentence from assembly language source codes 101. A first function division means 105 converts an instruction inside high-level language source codes 104 related to the labels into a format of a function, makes all the instructions inside the high-level language source codes 104 belong to the function, and divides the function by the label that is the argument of the call sentence converted into the function. <P>COPYRIGHT: (C)2005,JPO&NCIPI

Description

  The present invention relates to a source code described in an assembly language (hereinafter referred to as assembly language source code) executable by a CPU of a certain microcomputer (hereinafter referred to as a microcomputer) by a microcomputer equipped with another CPU. The present invention relates to a software conversion device that performs reverse conversion into executable high-level language (C, C ++, etc.) source code (hereinafter referred to as high-level language source code).

  As the set functions become multi-functional, opportunities for developing software using C language, C ++ language, etc., which are high-level languages, are increasing in software development of embedded microcomputers. On the other hand, there are many opportunities to divert assembly language software assets that have been used in the past, and there is a need to reverse-convert (decompile) assembly language source code into high-level language source code and centrally manage it using high-level language source code. It is increasing. Such a software conversion device (decompiler) is mainly used for software development of an embedded microcomputer (for example, see Patent Document 1).

A conventional software conversion apparatus performs reverse conversion by replacing assembly language instructions with corresponding high-level language instructions on a one-to-one basis.
For example,
Label equ *
MOV A, ram
ADD A, # 2
MOV ram, A
Assembly language source code, such as
Label:
D1 = ram;
D1 + = 2;
ram = D1;
It was converted into the corresponding high-level language source code.

However, since the conventional software conversion device only replaces the instruction one-to-one, it simply converts a branch instruction such as a call statement described in assembly language into a function call in a high-level language, and after decompilation. In the high-level language source code, the branch destination label (such as a label that is an argument of the call statement) remains as it is without being converted into a function. For this reason, when compiling high-level language source code after decompilation, there are many cases in which the function call branch destination function does not exist and an error occurs and compilation is not possible.
JP-T-2001-515240 (pages 9-16, Fig. 1)

  In view of the above problems, the present invention converts an instruction related to a head label and a branch label (such as a label that is an argument of a call statement) in a high-level language source code after decompilation into a function format. An object of the present invention is to provide a software conversion device that generates a source code that conforms to the grammar of a high-level language by making all instructions in a language source code belong to a function and dividing the function by a functionalized branch label. To do.

  On the other hand, when all the instructions belong to the function and the function is divided by the functionalized branch label, the branch destination label of the instruction that branches to the label (such as a goto statement) is the function of the branch instruction. There is a possibility that it will become a label out of the unit and cannot be compiled.

  Therefore, in view of the above problems, the present invention converts an instruction in a high-level language source code related to a branch destination label of an instruction that branches to a label outside a function unit into a function format, and converts the high-level language source code into the function format. It is an object of the present invention to provide a software conversion device that generates source code in accordance with a grammar of a high-level language by further dividing by a branch destination label.

  The software conversion device according to claim 1 of the present invention is a software conversion device that reversely converts assembly language source code into high-level language source code, and a label detection means for detecting a leading label and a branch label from the assembly language source code. And a first function division for converting an instruction in the high-level language source code related to the detected label into a function format according to the detection result of the label detection means, and dividing the high-level language source code by a branch label. Means.

  A software conversion device according to claim 2 of the present invention is the software conversion device according to claim 1, wherein the high-level language source code converted into the function format by the first function dividing means is different from the high-level language source code. Branch destination label detection means for detecting a branch destination label of a branch instruction that branches to a label in a function unit, and a high-level language related to the detected branch destination label according to the detection result of the branch destination label detection means A function for converting an instruction in the source code into a function format, dividing the high-level language source code by the branch destination label, and branching a branch instruction for branching to the label in the other function unit to the function And a second function dividing means for replacing with a call.

  The software conversion device according to claim 3 of the present invention is the software conversion device according to any one of claims 1 and 2, wherein the first function dividing means uses a first label of the high-level language source code as a function. At the end of the high-level language source code, a symbol indicating the end of the function is inserted, and the instruction below the first label of the high-level language source code is used as an instruction in the function. The high-level language source code is divided by inserting a symbol representing the division of the function.

  The software conversion device according to claim 4 of the present invention is the software conversion device according to any one of claims 2 to 3, wherein the second function dividing means converts the label of the branch destination into a function. The high-level language source code is divided by inserting a symbol representing the division of the function immediately before that.

  The software conversion device according to claim 5 of the present invention is the software conversion device according to claim 3 or 4, wherein the first function dividing means includes a symbol representing the division of the function. In this case, a function call that branches to a functionalized branch label is inserted immediately before.

  A software conversion device according to a sixth aspect of the present invention is the software conversion device according to any one of the fourth or fifth aspects, wherein the second function dividing means includes a symbol representing the division of the function. , A function call for branching to a branch destination label that has been functionalized immediately before is inserted.

  The software conversion device according to claim 7 of the present invention is the software conversion device according to claim 6, wherein the instruction arranged immediately before the branch label or the branch destination label is a function end instruction. A function end instruction detecting unit for detecting, and an unnecessary instruction omitting unit for preventing a function call from being inserted immediately before the branch label or the branch destination label in response to detection of the function end instruction by the function end instruction detecting unit; It is characterized by providing.

  The software conversion device according to claim 8 of the present invention is the software conversion device according to any one of claims 3 to 7, wherein an instruction arranged immediately before the branch label or the branch destination label is a table. A table data instruction detecting means for detecting that the instruction is a data instruction, and in response to detection of the table data instruction by the table data instruction detecting means, an insertion destination of the symbol representing the division of the function is set to the branch label or the branch destination Table data arrangement changing means is provided immediately before the table data instruction instead of immediately before the label so that the table data instruction is arranged outside the function unit.

  A software conversion device according to claim 9 of the present invention is the software conversion device according to any one of claims 1 to 8, wherein the branch label is an argument of a call statement.

  The software conversion device according to claim 10 of the present invention is the software conversion device according to any one of claims 2 to 9, wherein the branch instruction for branching to the label in the other function unit is a goto statement. It is characterized by.

  A software conversion device according to an eleventh aspect of the present invention is the software conversion device according to any one of the seventh to tenth aspects, wherein the function end instruction is a return instruction or a goto instruction.

  According to the present invention, when an assembly language is decompiled into a high-level language (inverse conversion), even when an instruction that branches to a label such as a call statement is described in the assembly language, the branch destination of the branch instruction The label (branch label) is converted into a function, all the instructions in the high-level language source code belong to the function, and this function is divided by the functionalized branch label, so the source code conforming to the high-level language grammar is generated. can do.

  In addition, when all instructions belong to a function in this way and the function is divided by a functionalized branch label, the branch destination label of an instruction that branches to a label such as a goto statement is the function of the branch instruction. Even when the label is out of the unit, this branch instruction is replaced with a function call, the label of the branch destination is converted into a function, and the high-level language source code is further divided by the functionalized branch destination label. Source code that conforms to the grammar of high-level languages can be generated.

  In addition, when a function is divided by a functionalized branch label or a branch destination label, a function call that branches to the functionalized label immediately after that is inserted immediately before the symbol that divides the function. Even if processing is performed in the order of the flow of the language source code, logic consistency can be achieved.

  On the other hand, since the function call is not inserted when the instruction immediately before the branch label to be functionalized or the branch destination label is a function end instruction, the code size of the source code can be compressed.

  If the instruction immediately before the branch label to be converted or the label at the branch destination is a table data instruction, the function ends immediately before the table data instruction. Code can be generated.

Hereinafter, embodiments of the present invention will be described with reference to the drawings.
FIG. 1 is a schematic diagram showing a configuration of a software conversion apparatus according to the present embodiment.
In FIG. 1, a label detection unit 102 detects a leading label and a branch label (for example, a label that is an argument of a call statement) from the assembly language source code 101, and registers these labels in a database. The decompiler 103 decompiles the assembly language source code 101 and converts it into a high-level language source code 104.

  The first function dividing unit 105 converts an instruction in the high-level language source code 104 related to the label registered in the database into a function format, and divides the high-level language source code 104 by the branch label. Here, the first function dividing means 105 converts the leading label of the high-level language source code 104 into a function and inserts a symbol “}” indicating the end of the function at the end of the high-level language source code 104 to thereby convert the high-level language source code. The instruction below the first label of 104 is used as an instruction in the function, the branch label is converted into a function, and a symbol (} symbol) indicating the division of the function is inserted immediately before it to display the high-level language source code 104 Split.

Further, the first function dividing means 105 inserts a function call that branches to the branch label immediately before the branch label.
The function end instruction detection means 106 in the first function dividing means 105 detects a function end instruction such as a return instruction or a goto instruction arranged immediately before the branch label.

The unnecessary instruction omitting unit 107 prevents the function call from being inserted in response to the function end instruction detecting unit 106 detecting the function end instruction.
The table data instruction detecting means 108 detects a table data instruction arranged immediately before the branch label.

  When the table data instruction is detected by the table data instruction detecting means 108, the table data arrangement changing means 109 changes the insertion destination of the symbol “}” indicating the end of the function from immediately before the branch label to immediately before the table data instruction, The table data instruction is arranged outside the function unit described later.

  Further, the branch destination label detection unit 110 is a branch destination label of a branch instruction that branches to a label in another function unit from the high-level language source code converted into the function format by the first function division unit 105. Is detected.

  The second function dividing unit 111 converts an instruction in the high-level language source code related to the branch destination label detected by the branch destination label detecting unit 110 into a function format, and converts the high-level language source code into the branch destination label. Divide by label and replace the branch instruction with a function call to branch to the function. Here, the second function dividing unit 111 converts the label at the branch destination into a function, and inserts a symbol (} indicating a function end) “}” indicating the division of the function immediately before it, and outputs the high-level language source code. To divide.

Further, the second function dividing unit 111 inserts a function call that branches to the branch destination label immediately before the branch destination label.
In addition, the function end instruction detection means 106 in the second function dividing means 111 detects a function end instruction such as a return instruction or a goto instruction arranged immediately before the branch destination label.

The unnecessary instruction omitting unit 107 prevents the function call from being inserted in response to the function end instruction detecting unit 106 detecting the function end instruction.
The table data instruction detecting unit 108 detects a table data instruction arranged immediately before the branch destination label.

  When the table data instruction is detected by the table data instruction detecting means 108, the table data arrangement changing means 109 changes the insertion destination of the symbol “}” indicating the end of the function from immediately before the branch destination label to immediately before the table data instruction. The table data instruction is arranged outside the function unit described later.

The software conversion apparatus according to the present embodiment can obtain the target high-level language source code 112 by being configured as described above.
Hereinafter, the operation of the software conversion apparatus will be described in detail from the operations of the label detecting means and the first function dividing means.

  FIG. 2A is a flowchart for explaining the function division by searching for a call sentence. First, in step S201, all labels that are arguments of the call statement as the head label and branch label are searched from the assembly language source code. Next, in step S202, all the labels searched in step S201 are registered in the function table (database) 204. Finally, in step S203, based on the label registered in the function table 204, the first label in the high-level language source code obtained by decompiling the assembly language source code and the label that is the argument of the call statement are used. Convert related instructions to function form.

This conversion process is performed by the following process. For example, when the label Label1 is an argument of a call statement and is registered in the function table, the high-level language source code obtained by decompiling the assembly language source code includes:
Label1:
It is described. So, first, put a goto statement just before this label,
goto Label1;
Label1:
Then, a symbol indicating the end of the function (a symbol indicating the division of the function) “}” is inserted immediately before “Label1:”, and this label is converted into a function.
Label1 (); return;
}
void Label1 (void) {
Replace with Since the label Label1 is functionalized, “goto Label1;” is replaced with a function call “Label1 (); return;” for branching to the function.

  The first label is also registered in the function table 204, and the first label is converted into a function, and a symbol “}” indicating the end of the function is inserted at the end of the file, so that all instructions Belongs to a function.

For example, when the first label is a label Label1, high-level language source code obtained by decompiling assembly language source code includes:
Label1:
And this label is converted into a function, void Label1 (void) {
And the symbol “}” indicating the end of the function is inserted at the end of the file.

  As described above, the first label in the source code is converted into a function, and the symbol “}” indicating the end of the function is inserted at the end of the file, and immediately before the label (branch label) that is the argument of the call statement. By inserting the symbol “}” indicating the end of the function into a function and making this label a function, all instructions belong to the function, and the high-level language source code is divided by the label that is the argument of the call statement Is done.

FIG. 3 shows an example of function division by retrieval of a call sentence in the present embodiment.
First, from the assembly language source code 301, the label Label1 as the first label and the label Label3 as the argument of the call statement are registered in the function table.

  Next, based on this function table, the source code 302 obtained by decompiling the assembly language source code 301 is divided into functions. That is, after describing the goto statement “goto Label3;” immediately before the label Label3 into the source code 303, the label Label1 is functionalized to insert the symbol “}” indicating the end of the function at the end of the file, and the label Label3 A high-level language source code 304 that is function-divided by the label Label 3 is obtained by inserting the symbol “}” indicating the end of the function immediately before “” to make this label a function.

  Note that the goto statement “goto Label4” in the source code 303 is a goto instruction that branches to the label Label4, and therefore remains as it is, and the goto statement “goto Label3” is a goto instruction that branches to the function “void Label3 (void) {”. Therefore, the function call “Label 3 (); return;” is replaced.

  As described above, by performing function division by searching for a call statement, all instructions belong to functions. However, only this processing may leave a goto statement (branch instruction) that branches to a label outside the function.

For example, in the example shown in FIG. 3, goto Label4:
Therefore, the function “void Label1 (void) {” branches to the function “void Label3 (void) {”, and a problem occurs at the time of compiling without conforming to the grammar of the high-level language.

  Therefore, in this embodiment, in order to avoid this problem, function division is performed by searching for a goto statement that branches to a label outside the function by the branch destination label detection means and the second function division means.

FIG. 2B is a flowchart for explaining function division by searching for a goto sentence.
First, in step S211 at the start of processing, the function table 214 is the same as the function table 204 obtained at the time of function division processing by retrieval of a call statement.

  Next, in step S212, labels that are not functionalized (branch destination labels) are searched in order from the beginning of the source code after function division by the search of the call statement. If a non-functionalized label is found, all goto statements (branch instructions) that branch to that label are searched.

Subsequently, in step S213, it is determined whether or not the high-level language source code is function-divided using the label searched in step S212.
This determination process is performed as follows. That is, based on the function table 214, one functional unit is from the functionalized label to the line immediately before the next functionalized label, and the non-functionalized label and the goto statement branching to the label are the same. Determine whether it belongs to a function unit. If the unfunctionalized label and all the goto statements that branch to the label belong to the same function unit, the label and the goto statement are left as they are, and the process proceeds to step S212 to search for the next unfunctionalized label. Move on. On the other hand, if the label that is not functionalized and the goto statement that branches to the label belong to another function unit, the process proceeds to step S214, and the instruction in the high-level language source code related to the label is converted into the function format. . In this embodiment, the branch destination label of a branch instruction that branches to a label in another function unit is detected in this way.

The conversion process in step S214 is performed by the following process. For example, when the label Label1 is a non-functionalized label and the goto statement that branches to the label Label1 belongs to another function unit, the source code after the function division by the search of the call statement includes
Label1:
It is described. So, first, put a goto statement just before this label,
goto Label1;
Label1:
After that, a symbol indicating the end of the function (a symbol indicating the division of the function) “}” is inserted immediately before “Label1:”, and this label is converted into a function.
Label1 (); return;
}
void Label1 (void) {
And the high-level language source code is function-divided by the label Label1.

  In addition, since the label Label1 is functionalized in this way, “goto Label1;”, which is an instruction for branching to the label Label1, is replaced with a function call “Label1 (); return;” for branching to the function.

  After the label is newly converted into a function in this way, the process returns to step S211 to additionally register the label in the function table 214 (function list creation), and the search for the label that has not been converted to a function is started again from the beginning.

  By repeating the above processing until a label that is not functionalized and a goto statement that branches to the label all belong to the same function unit, a source code that conforms to the grammar of a high-level language can be obtained.

The function division by the search of the goto sentence will be described in accordance with an embodiment shown in FIG. In FIG. 4, the source code 304 is the same as the source code 304 shown in FIG.
First, labels that are not functionalized are searched in order from the top of the source code 304, and the label Label2 is detected. Next, a goto statement that branches to this label Label2 is searched. In the example shown in FIG. 4, since there is no goto statement (branch instruction that branches to a label in another function unit) branching from outside the function unit to this label, the label Label2 performs function division of the high-level language source code. Not performed.

  Subsequently, the labels that are not functionalized are sequentially searched again from the top of the source code 304, and the label Label4 is detected. Next, a goto statement that branches to this label Label4 is searched. In the example shown in FIG. 4, the label Label4 belongs to the function unit of the function “void Label3 (void) {”, and the goto statement branching to the label Label4 is assigned to a function “void Label1 (void) {” different from the function unit. Therefore, function division of the high-level language source code is performed with the label Label4.

  That is, after describing the goto statement “goto Label4;” immediately before the label Label4 in the source code 304 to form the source code 305, the symbol “}” indicating the end of the function is inserted immediately before the label Label4, and this label is used. By converting it into a function, the high-level language source code 306 divided by the label Label4 is obtained.

  Subsequently, a search for labels that are not functionalized is performed in order from the top of the source code 306. In the example shown in FIG. 4, since there are no more labels that are not functionalized, the operation ends here.

  As described above, the branch destination label of a goto statement (branch instruction) that branches to a label in another function unit is detected from the high-level language source code after function division by the search of the call statement, and this branch destination label is detected. By inserting the symbol “}” indicating the end of the function immediately before “”, converting this label into a function, and replacing the goto statement with a function call, a source code conforming to the grammar of the function of the high-level language can be obtained.

  In addition, function division is not performed every time a branch destination label of a goto statement (branch instruction) that branches to a label in another function unit is detected, but after all the corresponding labels are additionally registered in the function table, You may make it divide | segment.

  As described above, the function division by the search of the call sentence and the function division by the search of the goto sentence can obtain a source code in which all instructions belong to the function and comply with the grammar of the function of the high-level language.

However, these processes may add unnecessary instructions.
For example, in the example shown in FIGS. 3 and 4, when a label Label3 (branch label) and a label Label4 (branch destination label) are functionalized, a goto instruction (function call) is inserted immediately before the label.

  This instruction is arranged as a countermeasure when the processing of Label3 and Label4 is performed in the order of the source code flow without branching. However, in the example shown in FIGS. 3 and 4, since these instructions are arranged immediately after the return instruction, they are not executed.

  Therefore, in the present embodiment, when the function is divided by the function end instruction detection means and the unnecessary instruction deletion means, the instruction immediately before the division (the instruction immediately before the branch label or branch destination label) is the return instruction or the goto instruction. In the case of such a function end instruction, a goto instruction is not inserted immediately before a branch label or a branch destination label.

FIG. 5A is a flowchart for explaining function division when the instruction immediately before division is a return instruction or a goto instruction.
First, in step S501, when function division is performed by searching for a call statement or a goto statement, it is determined whether the instruction immediately before the division is a return instruction or a goto instruction. This determination process may be performed based on the function table or may be performed when a label is registered in the function table.

  If the instruction immediately before the division is a return instruction or a goto instruction, in step S502, the newly inserted goto instruction is omitted or a function division process is performed without inserting a goto instruction. In step S503, the goto instruction is arranged as it is, and function division processing is performed to ensure logic consistency.

  For example, when performing function division by retrieval of a call statement and function division by retrieval of a goto statement with respect to the source code 302 shown in FIG. 3, the above-described goto instruction is omitted so that the source code shown in FIG. 601 can be obtained. Compared with the source code 306 shown in FIG. 4, the source code 601 is a function call “Label3 () arranged before the functions“ void Label3 (void) {”and“ void Label4 (void) {”; "return;" and "Label4 (); return;" are omitted.

  Furthermore, when the source code includes a table data instruction, if the function is divided by searching for the above-described call statement or goto statement, the table data instruction is included in the function and converted into source code that does not conform to the grammar of the high-level language. There is a problem of being. Here, the table data instruction refers to a table in which only a data string used in, for example, a function on a program is tabulated.

  For example, when the function division by the search of the call statement and the function division by the search of the goto statement are performed on the source code 701 shown in FIG. 7A, the table data Table1 (dc) is generated along with the functionalization of the label Label4. 2 bytes are secured by the instruction) is converted into the source code 702 arranged inside the function.

  Therefore, in this embodiment, when the function is divided by the table data instruction search means and the table data arrangement change means, the instruction immediately before the division (the instruction immediately before the branch label or the branch destination label) is the table data instruction. In this case, the insertion destination of the symbol indicating the division of the function (the symbol indicating the end of the function) “}” is changed from immediately before the branch label or branch label to immediately before the table data instruction, and the arrangement of the table data instruction is changed. Change outside function unit.

FIG. 5B is a flowchart for explaining function division when the instruction immediately before division is a table data instruction.
First, in step S511, when performing function division by searching for a call statement or a goto statement, it is determined whether or not the instruction immediately before the division is a table data instruction. This determination process may be performed based on the function table or may be performed when a label is registered in the function table.

  If the instruction immediately before the division is a table data instruction, in step S512, the insertion destination of the symbol “}” indicating the end of the function is changed from immediately before the branch label or branch destination label to immediately before the table data instruction. Split. In the case of other instructions, in step S513, it is possible to obtain logical consistency by performing function division as it is.

  For example, when performing function division by calling a call statement and function division by searching a goto statement on the source code 701 shown in FIG. 7B, by performing the above-described processing for changing the arrangement of table data instructions, The source code 703 that does not include the table data Table1 in the function can be obtained. That is, when the label Label4 is functionalized in the source code 701, the insertion destination of the symbol “}” indicating the end of the function is changed from immediately before the label Label4 to immediately before the label “Table1:” indicating the table data instruction. It is possible to obtain source code 703 that does not include a table data instruction in the function.

  Processing for omitting the above-mentioned goto instruction by detecting a table data instruction arranged immediately before the division and detecting a return instruction or a goto instruction arranged immediately before the detected table data instruction. And processing for changing the arrangement of the table data may be performed together.

  Since the software conversion apparatus according to the present invention can generate a source code conforming to a high-level language grammar from an assembly language source code, an assembly language source code that can be executed by a CPU of a certain microcomputer is mounted on another CPU. It can be applied to a software conversion device that performs reverse conversion into high-level language source code that can be executed by a microcomputer.

Schematic which shows the structure of the software conversion apparatus in embodiment of this invention Flowchart diagram for explaining the operation of the software conversion apparatus according to the embodiment of the present invention (No. 1) (a) Flowchart diagram for explaining function division by retrieval of call statement (b) Function division by retrieval of goto statement Flow chart for explaining The figure which shows one implementation of the function division | segmentation by the search of the call sentence in embodiment of this invention The figure which shows one implementation of the function division | segmentation by the search of a goto sentence in embodiment of this invention Flowchart diagram for explaining the operation of the software conversion apparatus according to the embodiment of the present invention (No. 2) (a) Flowchart diagram for explaining function division when the instruction immediately before division is a return instruction or a goto instruction ( b) Flowchart diagram for explaining function division when the instruction immediately before division is a table data instruction The figure which shows one implementation of the function division | segmentation at the time of performing the process which omits the goto instruction in embodiment of this invention The figure which shows one implementation of the function division | segmentation at the time of performing the process which changes arrangement | positioning of the table data instruction in embodiment of this invention

Explanation of symbols

101 assembly language source code 102 label detection means 103 decompiler 104 high-level language source code 105 first function division means 106 function end instruction detection means 107 unnecessary instruction omission means 108 table data instruction detection means 109 table data arrangement change means 110 branch destination Label detecting means 111 Second function dividing means 112 Target high-level language source code

Claims (11)

In a software conversion device that converts assembly language source code back to high-level language source code,
Label detection means for detecting the leading label and branch label from assembly language source code;
First function dividing means for converting an instruction in the high-level language source code related to the detected label into a function format according to the detection result of the label detection means, and dividing the high-level language source code by a branch label; A software conversion device comprising: The software conversion device according to claim 1,
Branch destination label detecting means for detecting a branch destination label of a branch instruction that branches to a label in another function unit from the high-level language source code converted into the function format by the first function dividing means;
In accordance with the detection result of the branch destination label detection means, the instruction in the high-level language source code related to the detected branch destination label is converted into a function format, and the high-level language source code is converted into the branch destination label. A software conversion device comprising: a second function dividing unit that divides and replaces a branch instruction that branches to a label in another function unit with a function call for branching to a function.   The first function dividing means converts the leading label of the high-level language source code into a function and inserts a symbol indicating the end of the function at the end of the high-level language source code so as to be equal to or lower than the leading label of the high-level language source code. 3. The high-level language source code according to claim 1, wherein an instruction is an instruction in a function, the branch label is converted into a function, and a symbol representing the division of the function is inserted immediately before the high-level language source code. The software converter described in 1.   4. The high-level language source code according to claim 2, wherein the second function dividing means divides the high-level language source code by converting the label at the branch destination into a function and inserting a symbol representing the division of the function immediately before the function. The software conversion apparatus in any one of.   5. The first function dividing means inserts a function call that branches to a branch label that has been functionalized immediately before it, in addition to a symbol that represents the division of the function. The software converter described in 1.   6. The function dividing unit according to claim 4, wherein the second function dividing unit inserts a function call that branches to a branch destination label that has been functionalized immediately before the symbol that represents the division of the function. The software conversion apparatus in any one. The software conversion device according to claim 6,
Function end instruction detection means for detecting that an instruction arranged immediately before the branch label or the branch destination label is a function end instruction;
Software conversion comprising: unnecessary instruction omission means for preventing a function call from being inserted immediately before the branch label or the branch destination label in response to detection of a function end instruction by the function end instruction detection means apparatus. A software conversion device according to any one of claims 3 to 7,
Table data instruction detection means for detecting that an instruction arranged immediately before the branch label or the branch destination label is a table data instruction;
In response to detection of the table data instruction by the table data instruction detection means, the insertion destination of the symbol representing the division of the function is changed to immediately before the table data instruction instead of immediately before the branch label or the branch destination label, and the table data A software conversion apparatus comprising: table data arrangement changing means for arranging an instruction outside a function unit.   9. The software conversion apparatus according to claim 1, wherein the branch label is an argument of a call statement.   10. The software conversion apparatus according to claim 2, wherein the branch instruction for branching to a label in another function unit is a goto statement. 11. The software conversion apparatus according to claim 7, wherein the function end instruction is a return instruction or a goto instruction.

Images