JP2000035882A - Method for dynamic change of function calling sequence - Google Patents

Abstract

PROBLEM TO BE SOLVED: To dynamically change a calling sequence of the function of a different product by setting the head address of the execution part of the function being the object of an order change to a prescribed place in a function call table. SOLUTION: The address of a function call table where the head address of the substantial execution part of Y function being one of the objects of an order change is stored is obtained. The stored head address of the substantial execution part of Y function is acquired and the head address is saved from the function call table (S1 and 2). The address of the function call table where the head address of the substantial execution part of B function being the other of the objects is stored is obtained. The stored head address of the substantial execution part of B function is obtained and the head address is saved from the function call table (S3 and 4). The head address of the substantial execution part of B function is set in the table address and the head address of the substantial execution part of Y function is set in the table address (S5). Then, the function call table is rewritten.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a method of changing a function calling procedure in a computer program, and particularly to a method of dynamically changing a function calling procedure in a program whose execution format cannot be changed, for example, when the source code is not disclosed. How to do it.

[0002]

2. Description of the Related Art Heretofore, in order to change the procedure of a function call, a method of statically changing the source program and re-creating an executable form has been used. For this reason, the function call procedure can be changed only by a program whose source code is disclosed and whose executable form can be re-created (that is, a program created by itself and hereinafter referred to as its own program). there were.

[0003]

On the other hand, in recent program development, another product (for which the source code is not disclosed or the source code is disclosed, In general, a method of creating an executable form by linking (joining) a library (a collection of functions and data used in a program) provided by a department that provides functions that cannot create an executable form has become common. I have. In this way, for example, a function in the program of another product is added to its own program developed using the library of another product (that is, a program whose executable form cannot be changed, and is hereinafter referred to as a program of another product). (Hereinafter referred to as a function of another product), if there is a problem such as an unexpected value or the operation time of the function of another product is too long, You need to determine whether it is a bug in the function or a bug in another function that it calls. Therefore, as a method of performing the separation, a method of changing a procedure for calling a function of another product to a desired procedure has been considered. However, in the prior art, as described above, it is possible to change the procedure for calling a function in its own program by statically changing the source program although it is not easy. There is a problem that it is impossible to change a procedure for calling a function of another product to a desired procedure.

[0004] In view of the above, there has been a demand for the development of a method for dynamically changing a function calling procedure that can change a procedure for calling a function of another product to a desired procedure.

[0005]

According to the method of dynamically changing the procedure of a function call according to the present invention, among the functions included in the first program whose execution format cannot be changed, the function whose order is to be changed is the first function. Call order of a function in the first program by adding a call to a function in the second program using the first or first program when the order of calls in the first program is known in advance Is changed during execution of the second program, comprising a function call table in which a callee to a function called in the second program is stored, wherein the added function is a recursive function, The second program is known in advance in a location in the function call table where a callee to the function whose order is to be changed is stored. And a function call table rewriting process for rewriting the function call table by replacing the call destination stored in the location based on the calling order and storing the call destination. When the second program is executed, the function call table is rewritten. The call destination to the function whose order is to be changed is saved, and the saved call destination is set at a predetermined location in the function call table based on the function call table rewriting process, thereby changing the function calling procedure. . Note that the first program corresponds to a program of another product of the embodiment described later, and the second program similarly corresponds to its own program of the embodiment described later.

According to the present invention, during execution of the second program, the actual execution of the function whose order is to be changed among the start addresses stored in the function call table is performed based on the function call table rewriting process. The head address of the section is set at a predetermined location in the function call table, and the procedure of the function call is dynamically changed.

[0007]

FIG. 1 is a flow chart showing the flow of processing according to an embodiment of the present invention, and FIG. 2 is a method to dynamically change the procedure of a function call according to an embodiment of the present invention. FIG. 2 is a block diagram showing a configuration of a system performed.
In this system, 1 is an auxiliary storage device for storing its own program and another product's program, and 2 is an R storage device.
AM, 3 is a ROM, 4 is an input device such as a keyboard, and 5 is a CPU. When execution of the program is instructed by the input device 4, the CPU 5 reads the program from the auxiliary storage device 1 and stores the program in the ROM 3. The program is stored in the RAM 2 by the loading program and the program is executed.

Next, the types of the function call order change will be described. This type is shown in the following (a) to (d).
Note that the functions X, Y, and Z in the following description may be any of the functions in the own program and the functions of other products, and are arbitrary. (A) Adding a new function call to the current function call order For example, when changing function X → function Z in the order of function X → function Y → function Z (b) Changing function call order eg, function X → function Y → function When Z is changed in the order of function X → function Z → function Y (c) Changing the order of function calls For example, when changing function X → function Y in the order of function X → function Z (d) Deletion of function call order For example, function When changing X → function Y → function Z in order of function X → function Z

The operation of the present embodiment will be described below with reference to a flowchart of FIG. First Example Here, as an example corresponding to the above (a), a case where it is known that a function X of another product A calls a function Y of another product B (may be another product A) In the execution of the own program using the programs of the different product A and the different product B, a call which is originally performed in the order of the X function → the Y function is executed immediately before the Y function is actually executed. Function B is called, and after calling the B function, Y
An example in which a function is executed, that is, a case where the function is changed and called in the order of X function → B function → Y function will be described. In addition,
The processing for changing the calling order (function call table rewriting processing) is created based on the calling order that is known in advance, and is, of course, described in its own program. Executed before the function to be changed is called. When the calling order is changed by adding a new function to the current function call as in the case of (a), the added function (the B function in this case) is a recursive function (the self function). Function that calls itself). When the execution of the own program is instructed by the input device 4, the CPU 5 stores the own program in the auxiliary storage device 1.
And stored in the RAM 2 by the loading program stored in the ROM 3.

FIG. 3 shows that the program of the first example is R
FIG. 3 is a diagram schematically illustrating a memory area secured on an AM.
As shown in FIG. 3, the own program stored in the memory (RAM2) includes a program execution unit, a program execution unit, a function call table, a program execution unit of another product A, and a program execution unit of another product B. Is secured in a protected area on the memory, and as described here, when its own program uses a program of another product, the execution unit of the program of another product And is operated as a part of its own program.

The program execution unit is a part that actually describes the flow of processing. Here, the order of calling functions (including functions of own program / functions of different products A and B) is described. That is, addresses of a function call table described later corresponding to the call destination function are stored in the order of call. Therefore, the rewriting process of the function call table is stored before the call of the function X whose order is to be changed is performed. The program execution unit is a part that actually describes the flow of processing. Here, the execution unit of each function group created by itself is stored. The function call table is a part storing call destinations. Here, the start address of a memory area in which substantial execution units of all functions of the call destination are stored is stored. The execution unit of the program of another product stores the actual execution unit of the function of another product.

Then, after mapping as shown in FIG.
The CPU 5 starts executing the program. First, the operation is performed based on the function call table rewriting process of the program execution unit. That is, the address (here, the table address) of the function call table that stores the actual start address of the actual execution part of one of the Y functions whose order is to be changed is obtained, and stored at the location of the obtained address. The start address of the actual execution part of the Y function is obtained (see S1 in FIG. 1), and the start address is saved from the function call table (see S2 in FIG. 1). Similarly, an address (here, a table address) of a function call table in which the head address of the actual execution part of the other B function is stored is obtained, and the B function stored in the location of the obtained address is obtained. The start address of the actual execution unit is obtained (see S3 in FIG. 1), and the start address is saved from the function call table (see S4 in FIG. 1). Then, the function call table is rewritten. Hereinafter, this rewriting operation will be described.

FIG. 4 is a diagram schematically showing a memory area after rewriting. As shown in FIG. 4, the start address of the actual execution part of the B function is set at the table address, and the start address of the actual execution part of the Y function is set at the table address (see S5 in FIG. 1). Thus, the function call table is rewritten.

When the operation based on the function call table rewriting process described above is completed, the X in the function call table address stored in the function call table address is obtained according to the table form function call table address stored in the program execution unit.
The start address of the actual execution part of the function is specified, the X function at the specified address is executed, and the B address stored in the function call table address is obtained from the table address stored in the X function execution part. The head address of the actual execution unit is specified, and the B function at the specified address is executed. Then, based on the table address stored in the B function execution unit, the actual start address of the execution unit of the Y function stored in the function call table address is specified, and the Y function at the specified address is executed. . That is, the function is executed in the order of X function → B function → Y function.

FIG. 5 is a diagram showing a memory map for explaining the first example, and shows a specific example of FIGS. 3 and 4. 5, (1) corresponds to FIG. 3, and (2) corresponds to the function call table of FIG. Hereinafter, RA
The operation of the present embodiment after loading to M2 will be briefly described again based on the specific example of FIG. First, the operation is performed based on the function call table rewriting process of the program execution unit. That is, the address 3 of the function call table in which the start address of the execution part of the Y function is stored
008, the start address 5200 stored at the address 3008 is saved, and the address 30 of the function call table storing the start address of the execution unit of the B function is stored.
The first address 2000 stored at the address 3000 is saved to find 00. Then, the start address 2000 of the execution unit of the B function is set at address 3008, the start address 5200 of the execution unit of the Y function is set at address 3000,
Thus, the function call table is rewritten.

When the operation based on the function call table rewriting process is completed, the data 5100 stored in the address 3004 of the function call table is obtained from the table address 3004 stored in the program execution unit.
Is identified, the X function at address 5100 is executed, and X
The data 2000 stored at the address 3008 in the function call table is specified by the table address 3008 stored in the function execution unit, and the B function at the address 2000 is executed. Then, the data 5200 stored at the address 3000 of the function call table is specified by the table address 3000 stored in the B function execution unit,
The Y function at address 5200 is executed. That is, the call is performed in the order of X function → B function → Y function.

Second Example The method corresponding to the above (a) can also be used to change the order of function calls of functions in their own programs. For example, if your program calls a function of another product (which may be a function in your own program), before calling that function, another function (this function must be a recursive function. Which is naturally a function in the program of
In this case, the procedure for calling the function itself in the own program is changed. Of course, in this case, it is possible to change the source program without using the above method, but if your own program is coded to call the same function of another product at multiple locations, Becomes a plurality of places, and the greater the number, the more difficult the change work. Therefore, the calling order can be changed by adding the function call table rewriting process before the function call for changing the order is performed. For this reason, the trouble of correction can be largely saved.

Hereinafter, a specific example will be described. For example, if the function B, function C, and function D in the own program are functions that call the function X of another product A, respectively, the function Y (recursive Function), that is, B
A brief description will be given of a case where it is desired to call in the order of function → Y function → X function, C function → Y function → X function, D function → Y function → X function. FIG. 6 is a diagram showing a memory map in this case. (3) shows the memory map before the change,
(4) shows the function call table after the change.

When its own program is executed, an operation is performed based on the function call table rewriting process,
The start address 2300 of the execution part of the Y function stored at the address 3012 of the function call table and the start address 5100 of the execution part of the X function stored at the address 3016 of the function call table are exchanged into the function call table. Is stored. Then, the B function is executed by the table address 3000 stored in the program execution unit, the Y function is executed by the table address 3016 stored in the B function execution unit, and the table address stored in the Y function execution unit X by 3012
The function is executed. That is, the call is performed in the order of the B function → the Y function → the X function. The same applies to the case of the C function and the case of the D function, and a description thereof will be omitted.

Third Example As an example corresponding to the above (b), for example, its own program calls the X function of another product A,
The X function has a Y function and a Z function of another product B,
When it is known that the functions are to be called in this order, when the function X of this another product A is called in the own program, the call which is originally performed in the order of X function → Y function → Z function is called X An example will be described in which a function is changed and then a Z function is changed and then a Y function is called. Note that the process for changing the calling order (function call table rewriting process) is created based on a previously known calling order, as in the first and second examples. Of course, it is described in its own program, and is executed before the function whose order is to be changed is called.

FIG. 7 is a diagram showing a memory map for explaining the third example. (5) shows a memory map before change, and (6) shows a function call table after change. ing. Then, as shown in FIG. 7, after the mapping, the CPU 5 starts executing the program. First, the operation is performed based on the function call table rewriting process of the program execution unit. That is, the address 3004 of the function call table storing the start address of the actual execution part of one Y function whose order is to be changed is obtained, and the start of the actual execution part of the Y function stored at address 3004 is obtained. The address 6100 is acquired, and the head address is saved from the function call table. Similarly, an address 3008 of the function call table storing the head address of the actual execution part of the other Z function is obtained, and the start address 6200 of the actual execution part of the Z function stored at the address 3008 is obtained. Obtain and save the head address from the function call table. And 30
At the address 04, the start address 620 of the actual execution part of the Z function
0 is set, and the start address 6100 of the actual execution part of the Y function is set at address 3008.

When the operation based on the function call table rewriting process ends, the program execution unit 10
The data 5100 stored at address 3000 in the function call table is specified by the table address 3000 stored at address 00, and the X function at address 5100 is executed. That is, 620 is obtained by the table address 3004 stored at the address 5104 of the X function execution unit.
The Z function at address 0 is executed, and the table address 3008 stored at address 5108 of the X function execution unit
As a result, the Y function at address 6100 is executed. That is, the calling is performed in the order of X function → Z function → Y function.

Fourth Example Hereinafter, when the above (c) is changed in the order of the function X → the function Y, the function X → the function Z, (d) is changed in the order of the function X → the function Y → the function Z → the function X → the function Z The case of changing will be described as an example. Note that these cases (c) and (d) are the same as those described above, and will be briefly described here. The own program includes a function call table rewriting process in which the start addresses of the actual execution units of the functions Y and Z, which are the order change targets, stored in the function call table are exchanged and set in the function call table. When the own program is executed, the function call table is rewritten based on the rewriting process, and the procedure of the function call is changed.

According to this embodiment, during execution of its own program, the address of the function call table in which the head address of the memory area in which the function execution unit whose order is to be changed is stored is obtained. The function call table can be dynamically rewritten by saving the start address in the function call table to a predetermined location in the function call table based on the function call table rewriting process. . As a result, when a function call is made using the function call table, the order of the functions in another product is changed and called, which cannot be realized by the conventional method of changing the function call procedure.
The procedure for calling a function in another product can be dynamically changed.

Further, if the method of the present embodiment is applied to its own program and executed, it is possible to change the order of function calls in its own program, and as in the second example, its own program If a function is coded to call a function multiple times, and if you change the calling procedure to call another function before this function, you can change the calling sequence without modifying multiple points in your program. Function calling procedure can be changed, and the time and effort for modification can be greatly reduced.

After rewriting the function call table and changing the procedure of the function call, if it is necessary to call the original function call before the change under some conditions, the function call table before the change is changed to its own. It is separately stored in the same protected area of the execution part of the program, and is used for the original function call using the function call table before the change at the required timing.

In this embodiment, the method of rewriting the function call table storing the call destination has been described. However, in the memory area storing the execution unit of the program of another product, the execution of the function whose order is to be changed is executed. In the place where the part is stored, the actual execution part of the program of another product is rewritten by replacing and storing the execution part of the function whose order is to be changed based on a known calling order, and The procedure may be changed. In this case, the actual execution part itself of another product will be rewritten, so if it is necessary to call the original function before the change under some conditions after changing the procedure of the function call, this additional A copy of the actual execution unit of the product is created in the same protected area of the execution unit of its own program, and called at the required timing.

Further, by rewriting the function call table or rewriting the actual execution part of another product as described above, the execution of the function part of the program of another product is suppressed or the function of the function is changed. Becomes possible.

[0029]

According to the present invention as described above,
Dynamic rewriting of the function call table by setting the call destination to the function whose order is to be changed during execution of the second program at a predetermined location in the function call table based on the function call table rewriting process Can be. As a result, when a function call is performed using the function call table, the functions are called in a changed order of the functions in the first program, which cannot be realized by a conventional method of changing the function call procedure. Further, it is possible to dynamically change a procedure for calling a function in the first program.

[Brief description of the drawings]

FIG. 1 is a flowchart showing a flow of processing according to an embodiment of the present invention.

FIG. 2 is a diagram showing a configuration of a system to which a method of dynamically changing a function call procedure according to an embodiment of the present invention is applied;

FIG. 3 is a diagram schematically illustrating a memory area in which a program of the first example is secured on a RAM.

FIG. 4 is a diagram schematically showing a memory area after rewriting of FIG. 3;

FIG. 5 is a diagram showing a memory map for explaining a first example;

FIG. 6 is a diagram showing a memory map for explaining a second example.

FIG. 7 is a diagram showing a memory map for explaining a third example;

[Explanation of symbols]

 REFERENCE SIGNS LIST 1 auxiliary storage device 2 RAM 3 ROM 4 input device 5 CPU

 ────────────────────────────────────────────────── ─── Continued on the front page (72) Inventor Kyoko Shirane 18-28, Kuwata-cho, Okayama-shi, Okayama Oki Software Inc. Okayamauchi (72) Inventor Masao Shigehiro 1-7-12 Toranomon, Minato-ku, Tokyo Oki Electric Industrial Co., Ltd. F term (reference) 5B076 EA10 EA17

Claims (6)

[Claims] When the order in which a function whose order is to be changed among functions included in a first program whose execution format cannot be changed is called in the first program is known in advance, the first or the first program is not executed. A method of changing a sequence of calling a function in a first program during execution of the second program by adding a call to a function in a second program using the first program, comprising: A function call table in which a callee to a function called in the second program is stored, the added function is a recursive function, and the second
The program replaces the call destination stored in the location in the function call table based on the known call order in the location where the call destination to the function whose order is to be changed is stored. And a function call table rewriting process for rewriting the function call table by storing the function call table. When the second program is executed, a call destination from the function call table to the function whose order is to be changed is saved. Based on the call table rewriting process, the saved call destination is set at a predetermined location in the function call table, and the function call procedure is changed. The function call procedure is dynamically changed. Method. 2. An order in which a function whose order is to be changed among functions included in a first program whose executable form cannot be changed in a second program using the first program is known in advance. If the first
Or, a method of changing the order in which functions in the first program are called during the execution of the second program by adding calls to functions in the second program, wherein the order is called in the second program. A function call table in which a callee to the function is stored, wherein the added function is a recursive function, and
The program replaces the call destination stored in the location in the function call table based on the known call order in the location where the call destination to the function whose order is to be changed is stored. And a function call table rewriting process for rewriting the function call table by storing the function call table. When the second program is executed, a call destination from the function call table to the function whose order is to be changed is saved. Based on the call table rewriting process, the saved call destination is set at a predetermined location in the function call table, and the function call procedure is changed. The function call procedure is dynamically changed. Method. 3. The method according to claim 1, wherein, among functions included in the first program whose execution format cannot be changed, the order in which the functions whose order is to be changed is called in the first program is known in advance. A method for changing the order in which functions in a first program are called during execution of a second program using a function call table, wherein a function call table in which a callee to a function called in the second program is stored is stored. And the second program stores, in the function call table, a place where a callee to the function whose order is to be changed is stored, based on the call order that is known in advance, and Function call table rewriting process that rewrites the function call table by replacing the stored call destination and storing Including and in,
When the second program is executed, a call destination to the function whose order is to be changed is saved from the function call table, and the saved call destination is stored in the function call table based on the function call table rewriting process. A method of dynamically changing the procedure of a function call, wherein the method is set at a predetermined location and the procedure of a function call is changed. 4. A function call table before saving a call destination from the function call table to a function whose order is to be changed is separately stored, and when necessary, the function call table is used to save a call destination before saving. 4. The method according to claim 1, wherein the procedure is returned to a call destination. 5. The function call according to claim 1, wherein a call destination to the function is a head address of a memory area in which an execution unit of the function is stored. How to change the procedure dynamically. 6. A method according to claim 1, wherein, among the functions included in the first program whose execution format cannot be changed, the order in which the functions whose order is to be changed is called in the first program is known in advance. A method of changing the order in which functions in a first program are called during execution of a second program using the second program, wherein the second program is a memory area in which an execution unit of the second program is stored Out of the execution unit of the function whose order is to be changed is stored in the place where the execution unit of the function whose order is to be changed is stored based on the calling sequence that is known in advance, thereby storing the second one. An execution unit rewriting process for rewriting an execution unit of the program, wherein when the second program is executed, the order change is performed based on the execution unit rewriting process. The execution unit of the elephant function is set at a predetermined location of the execution unit of the second program, and the execution unit of the second program before the change is separately stored. A method of dynamically changing the procedure of a function call, wherein the procedure is returned to an execution unit of a program.