JP5109808B2 - Additional executable information generating apparatus, information processing apparatus, and program - Google Patents

Description

  The present invention relates to an additional executable information generating device, an information processing device, and a program.

The software is subdivided to set modules, and the relationship of symbol reference across the modules is extracted. Then, in a referenced module that has a reference relationship between modules, create a table that defines the acceptance reference address for symbol reference from other modules, and link the acceptance reference address to the actual address of the symbol reference destination in its own module Patent Document 1 discloses an embedded software development device that includes a section and a vector table / symbol information creating section that rewrites a referenced address from another module to an accepted reference address of a vector table.
JP 2004-192604 A

  In order to reduce the load on symbol reference in a module, embedded software generally performs symbol reference with fixed address information (absolute address object code). However, when making absolute address object code, even when some of the modules are modified, all modules are linked again, and the entire object code after linking is stored in a storage medium for testing. There is a need.

The invention according to claim 1 is an additional executable information generating device, the identification information of the call target included in the computer-executable execution information fixed to the storage medium, and the storage position in the storage medium Storage means for associating and storing, generation means for generating additional executable information including a processing instruction for calling a call target included in the execution information, and pre-execution information executed by a computer before execution of the execution information When the call target corresponding to the call target called by the execution information is included in the additional executable information, the execution information is rewritten, and the corresponding call target included in the additional executable information is changed. Pre-execution information generation means for generating pre-execution information to be set to be called, wherein the generation means is the storage means Referring to the stored information, and when the additional executable information to be generated includes a processing instruction for calling the calling target in the execution information, a call instruction element for calling the calling target called by the processing instruction is generated, The processing instruction is rewritten to an instruction for calling a storage position of the corresponding call instruction element, and is output together with the call instruction element .

The invention described in claim 2 is a program that associates a computer with identification information of a call target included in computer-executable execution information fixed to a storage medium, and a storage position in the storage medium. Storage means for storing information, generating means for generating additional executable information including a processing instruction for calling a call target included in the execution information, and pre-execution information executed by a computer before the execution information is executed. When the call target corresponding to the call target called by the execution information is included in the additional executable information, the execution information is rewritten to call the corresponding call target included in the additional executable information Function as pre-execution information generating means for generating pre-execution information to be set, and as the generating means When the processing instruction for calling the call target in the execution information is included in the generated additional executable information with reference to the information stored in the storage means. A call instruction element for calling is generated, and the processing instruction is rewritten to an instruction for calling a storage position of the corresponding call instruction element, and is output together with the call instruction element.

  According to the first and fifth aspects of the invention, even when a part of the module of the execution information is corrected, the execution module already stored in the storage medium from the corrected module is transferred to the call target in the other module. An address is set, and it is not necessary to link all modules again, and it is not necessary to store the entire object code after the link in the storage medium.

  Embodiments of the present invention will be described with reference to the drawings. An additional executable information generating apparatus 1 according to an embodiment of the present invention is illustrated in FIG. As illustrated in FIG. 1, the additional executable information generation apparatus 1 includes a control unit 11, a storage unit 12, an operation unit 13, and an output unit 14. The additional executable information generating apparatus 1 may also include a display device such as a display.

  The control unit 11 is a program control device such as a CPU (Central Processing Unit). The control unit 11 operates according to a program stored in the storage unit 12. The control unit 11 compiles the source code of the program to generate a binary code, and links the binary code to generate and output an object code. The source code to be compiled is stored in the storage unit 12, and the user (programmer) rewrites the source code as necessary.

  The additional executable information generating apparatus 1 according to the present embodiment uses a source code developed in a plurality of modules as a processing target. The source code of each module is generated individually, but calls internal functions and variables. When calling, a storage destination address (information indicating a storage position on a storage medium) such as a function or a variable to be called is used. That is, if the target of the call is a function, the instruction sequence stored from the storage destination address is read and processed. If the call target is a variable, the data held at the storage address is read. FIG. 2 shows a general process from source code compilation to linking.

  In the source code, for example, a function call command (C) included in the source code of another module is included. When the additional executable information generating apparatus 1 compiles the source code, identification information (for example, information including the function name) of the function to be called by this instruction is generated (D).

  Further, when an instruction to link each compilation result is given, the additional executable information generating device 1 refers to the identification information of the function to be called, and is identified by the identification information included in the compilation results of other modules. Get the storage address of the function. Then, the acquired storage destination address is set as a call command (E), and the process is completed. The same processing is performed for variables and the like.

  The additional executable information generating apparatus 1 of the present embodiment uses source code (original code) that is compiled and linked in advance and is the source of computer-executable execution information that is fixed to a storage medium. Process. When the source code of some modules of the original code is modified, the control unit 11 of the additional executable information generating apparatus 1 according to the present embodiment performs the following process according to the compile and link instructions To do.

  That is, the control unit 11 compiles the modified source code. When the compile result includes the identification information of the function and variable (call target) of another module to be called as the link process, the control unit 11 is already linked and the storage destination address is determined. The information of the storage destination address of the call target is acquired. The control unit 11 outputs additional executable information including the storage destination address. The details of the processing of the control unit 11 will be described in detail later.

  The storage unit 12 includes a RAM (Random Access Memory) and the like. The storage unit 12 holds a program executed by the control unit 11. This program may be provided by being stored in a computer-readable recording medium and copied to the storage unit 12. Further, in the present embodiment, a table (map information) that associates the identification information to be called and the storage destination address included in the executable information already stored in the storage unit 12 is retained (FIG. 3). ). This table may be generated together with executable information by the control unit 11 or the like and stored in the storage unit 12. Furthermore, the storage unit 12 also operates as a work memory for the control unit 11.

  The operation unit 13 includes a mouse, a keyboard, and the like. The operation unit 13 outputs the content of the user's operation to the control unit 11. The user operates the operation unit 13 to perform source code correction, compile / link instructions, and the like.

  The output unit 14 is a display, a network interface, or the like, and outputs information according to an instruction input from the control unit 11. The output unit 14 of the present embodiment includes a device that records executable information and additional executable information on a storage medium in accordance with an instruction input from the control unit 11.

  As illustrated in FIG. 4, the information processing apparatus 2 includes a storage medium reading unit 21, a control unit 22, a storage unit 23, an interface unit 24, and a function unit 25. Here, the storage medium reading unit 21 reads executable information and additional executable information stored in a storage medium such as a flash ROM (Read Only Memory) in accordance with an instruction from the control unit 22.

  The control unit 22 causes the storage unit 23 to copy executable information and additional executable information stored in the storage medium. Then, processing is performed according to the executable information and additional executable information stored in the storage unit 23. The control unit 22 may execute preprocessing according to a program designated as pre-execution information (patch) prior to copying executable information stored in the storage medium.

  The storage unit 23 includes a storage element such as a RAM. The storage unit 23 holds executable information read from the storage medium and additional executable information. The storage unit 23 also operates as a work memory for the control unit 22.

  The interface unit 24 outputs an instruction to the function unit 25 in accordance with the instruction input from the control unit 22. The interface unit 24 outputs information input from the function unit 25 to the control unit 22. For example, the function unit 25 is a printer engine or the like, and the control unit 22 outputs an instruction for image formation control to the function unit 25 via the interface unit 24.

  Next, operation | movement of the control part 11 of this Embodiment is described. Here, the control part 11 shall perform the process which produces | generates the executable information stored in a storage medium. When generating the executable information, the control unit 11 compiles the source codes of the modules to be included in the executable information, and links the compilation results to generate executable information. As already described, in this executable information, the storage destination address of a function or variable to be called between modules is specified (hard-coded). For example, as shown in FIG. 5, using the executable information including the first module A and the second module B, the function funcA1 () included in the first module A uses the function funcB1 ( ) Is called as follows:

  At the source code stage, in the funcA1 (), funcB1 () describes a call instruction using its identification information (for example, the name of funcB1 () itself). After the controller 11 compiles it, the storage destination address addrB1 of the executable information part of the function funcB1 () is acquired at the stage of linking and writing to the storage medium. Then, the control unit 11 rewrites the call of funcB1 () in funcA1 () to the call of the storage address addrB1.

  In this embodiment, identification information (symbol name) to be called in each module is stored in the storage unit 12 in association with its storage destination address. In the above example, the identification information of the function funcB1 () to be called is associated with the storage destination address addrB1 and stored in the storage unit 12 as map information illustrated in FIG.

  Next, the operation of the control unit 11 when generating additional executable information will be described. When the user rewrites the source code of some modules and issues a compile / link instruction, the control unit 11 executes the process illustrated in FIG.

  That is, the control unit 11 compiles the rewritten module source code (S1). In the following description, a module whose source code has been rewritten by the user is referred to as an addition target module, and a module whose source code has not been rewritten (a module that remains unchanged) is referred to as an existing module.

  The control unit 11 searches for a call target called from the addition target module (S2). Then, the control unit 11 refers to the map information held in the storage unit 12 and acquires each storage destination address associated with the identification information of each call target found as a result of the search (S3).

  In addition to the link instruction, the control unit 11 rewrites the call target call instruction to the corresponding storage destination address call instruction acquired in step S3 in the compilation result of the addition target module (S4). The control unit 11 adds the additional executable information generated in this way to the storage medium storing the executable information based on the module before rewriting (S5). The control unit 11 associates the identification information (symbol name) of the call target in each module to be added and the storage destination address (which may be a relative address from the top of the data in the compilation result, that is, an offset value). The additional executable information is stored in the storage unit 12.

  At this time, as illustrated in FIG. 7A, executable information (EX) before rewriting and additional executable information (AEX) are stored in the storage medium, and the executable information is added to the executable information from the additional executable information. Functions included, variables used in executable information, and the like are called according to address information based on map information.

  Further, in the present embodiment, when the executable information copied to the storage unit 23 includes a command for calling a function, variable, or the like in the module before rewriting, the command is rewritten, and the module after rewriting is performed. You may make it call the function and variable in.

  Therefore, when compiling / linking the addition target module, the control unit 11 corresponds to the call target (function, variable, etc.) defined in the addition target module as shown in FIG. The storage destination address to be called is acquired from the map information (S11).

  Further, the control unit 11 writes an instruction to acquire the storage address of the call target after rewriting (S12), and further stores the storage destination address of the call target in the module before rewriting as the storage address of the call target after rewriting. The pre-execution information is generated including the instruction to rewrite to (S13). And the control part 11 writes this prior execution information in a storage medium with additional executable information (S14).

  As described above, if there is a program designated as the pre-execution information, the control unit 22 of the information processing apparatus 2 copies the executable information and additional executable information stored in the storage medium to the storage unit 23. The pre-execution information is executed. As a result, the control unit 22 sets the storage destination address of the call target included in the additional executable information for the portion that should call the call target included in the additional executable information in the executable information corresponding to the module that has not been rewritten. Set. Therefore, a call target such as a function or a variable defined in the additional executable information is called from the executable information stored in the storage medium (FIG. 7B).

  In this process, in the process S11, it is not necessary to include, in the pre-execution information, a processing instruction for changing the storage destination address for all the functions and variables defined in the addition target module. In other words, referring to the executable information stored in the storage medium or the source code that is the source, the call target that is actually called among the functions and variables defined in the addition target module Only the processing instruction for changing the storage destination address may be included in the pre-execution information.

  In addition, when a call target defined as an interface to be called from an external module or the like is found in the source code of the addition target module, the interface to be called among the functions and variables defined in the addition target module A processing instruction for changing the storage destination address may be included in the pre-execution information only for the call target defined as Here, the specified call target as an interface may be, for example, a variable or function for which an extern declaration is made in the C language, or a class for which public is designated in the C ++ language. It may be a method or instance. Further, if there is a global variable defined in the rewritten module, the global variable may also be changed from the storage destination address in the module before rewriting to the storage destination address in the module after rewriting. .

  Since the additional executable information generation device 1 and the information processing device 2 of the present embodiment have the above-described configuration, they operate as follows.

  In the following, for the sake of explanation, it is assumed that executable information including two modules A and B is generated as illustrated in FIG. Here, at least a function funcA1 () and funcA2 () are defined in the module A. The function funcA1 () includes an instruction (indicated as call funcB1 () in the figure) that calls the function B of the module B as a call target.

  Module B defines at least functions funcB1 () and funcB2 (). The function funcB2 () includes an instruction for calling the function funcA2 () of the module A as a call target (denoted as call funcA2 () in the figure).

  When compiling and linking instructions are given for these modules, the additional executable information generating device 1 generates executable information in which the storage destination address of each calling target is defined (S21), and identifies the calling target. Map information in which the information (symbol) is associated with the storage destination address is generated (S22).

  Here, the executable information is stored in a storage medium and used for execution processing in the information processing apparatus 2. In this executable information, in the processing instruction sequence corresponding to the function funcA1 () in the module A, an instruction for calling the function funcB1 () of the module B is included, but the instruction is the function funcB1 ( ) Is set to an instruction that calls the storage destination address (addrB1) of the processing instruction sequence. Further, the processing instruction sequence corresponding to the function funcB2 () in the module B includes an instruction for calling the function funcA2 () of the module A. The instruction corresponds to the function funcA2 () that is the call target. It is set to an instruction that calls the storage address (addrA2) of the processing instruction sequence.

  Therefore, in the information processing apparatus 2, for example, when a processing instruction sequence corresponding to the function funcA1 () is processed, an instruction to call the storage destination address addrB1 is encountered as an instruction to call the function funcB1 () in the module B. , The instruction sequence stored under addrB1 is processed.

  On the other hand, the user rewrites module A to generate module A ′. This module A ′ is assumed to include the same call target as the call target included in the module A before rewriting. The additional executable information generating apparatus 1 compiles / links the module A ′ in accordance with a user instruction. At this time, the additional executable information generating apparatus 1 refers to the map information, and in the processing instruction sequence corresponding to the function funcA1 () in the module A, stores the instruction for calling the function funcB1 () of the module B. It is replaced with an instruction for calling an address (an instruction for calling an address addrB1 associated with the symbol funcB1) (S23).

  The result of compiling / linking the module A ′ after rewriting generated in this way is recorded as additional executable information. The storage destination address is different from the storage destination address of the corresponding function in the module A before rewriting, for example, the function funcA1 () is addedrA1 ′, the function funcA2 () is addrA2 ′, and so on. These storage destination addresses are determined when the additional executable information is read out in the information processing apparatus 2.

  Therefore, the additional executable information generating apparatus 1 obtains the function storage destination address in the module A ′ after rewriting, and the function storage destination address corresponding to the module A before rewriting corresponds to the module A ′ after rewriting. A command sequence to be rewritten to the storage destination address of the function to be generated is generated as pre-execution information (S24). The additional executable information and the pre-execution information are stored in the same storage medium as the original executable information, for example.

  This pre-execution information includes an index, a corresponding storage target address (old address) in the module before rewriting, and a corresponding storage target address (new address) in the rewritten module. And a program that performs a process of rewriting the old address associated with the key index to the new address while incrementing the index using the index as a key.

  The information processing apparatus 2 reads the executable information and the additional executable information from the storage medium and records them in the work memory. That is, the information processing apparatus 2 first reads executable information from the storage medium, and records it after a predetermined address in the work memory. Further, the information processing apparatus 2 reads the additional executable information and records it in a free area of the work memory. At this time, the information processing device 2 sets the recording start address of the additional execution information for the function in the rewritten module included in the additional execution information stored in the work memory, and the offset of each function included in the additional execution information. Each is added to (relative address from the head address) to obtain the actual storage destination address of each function.

  The information processing apparatus 2 stores the actual storage destination address for each function in the module after rewriting. Thereafter, the information processing apparatus 2 starts processing the executable information and the additional executable information recorded in the work memory, but performs the pre-execution information processing prior to the execution. In this processing, the information processing apparatus 2 refers to the information of the storage destination address of each function in the rewritten module A ′ recorded earlier, and corresponds to the function funcB2 () of the module B that has not been rewritten in the executable information. In the processing instruction sequence to be executed, an instruction to call the function funcA2 () (originally an instruction to call addrA2) is used as an instruction to call the function funcA2 () in the rewritten module A ′ (for example, addrA2 which is an address of the storage destination of the function) (Instruction to call “)” (S25).

  Therefore, in the information processing apparatus 2, in the process corresponding to the module A ′, addrB1 is called, so that the processing instruction corresponding to the function funcB1 () of the module B before rewriting included in the executable information. The column will be executed. Further, the function funcA2 () in the module A ′ is executed by calling the storage destination address addrA2 ′ instead of the module A from the module B before rewriting.

  Here, when generating additional executable information, the instruction is described so that the storage destination address of the call target is directly called in the result of compilation / link with reference to the map information. The form of is not limited to this.

  For example, the additional executable information generating device 1 of the present embodiment may operate as follows. That is, when the additional executable information generating apparatus 1 generates additional executable information, if there is an instruction for calling the call target in another module, the additional executable information generating apparatus 1 calls the storage destination address (obtained from the map information) ( For example, an instruction element describing an instruction that jumps to a storage destination address) is generated. This is generated for each call instruction, and a call instruction element group (jump table) is generated.

  The additional executable information generating apparatus 1 synthesizes this call instruction element group and the result of compilation into additional executable information (FIG. 10). In this case, in the additional executable information, the instruction for calling the call target includes a jump instruction to the corresponding call instruction element. In this case, for example, in the function funcA1 () of the module A ′, a call instruction element “call addrB1” for calling the function funcB1 () of the module B is generated with reference to the map information. This call instruction element is stored in the storage address addrCallB1.

  In this case, in the module A ′, all the instructions for calling the function funcB1 () of the module B are rewritten to call the storage destination address addrCallB1 in which the call instruction element for calling the funcB1 () is stored.

  Therefore, in the information processing apparatus 2, when additional executable information with the call instruction element group is recorded, the call instruction element is executed according to the instruction for calling the call instruction element, and another module is called by the executed call instruction element. Call. In such a case, the executable information not including the call instruction element group and the additional executable information including the call instruction element group coexist.

  In addition, in the above description, when additional executable information and pre-execution information are recorded together with executable information, the information processing apparatus 2 executes the pre-execution information or performs additional execution without making any special determination. The information processing apparatus 2 refers to the module identification information when the module identification information such as the version information is included in the executable information or the additional executable information, for example, and adds the executable information to the additional executable information. Of the portions corresponding to each module included, those not including the module identification information included in the executable information may not be read.

  Furthermore, if additional executable information and pre-execution information are recorded together with executable information, the pre-execution information is executed, the additional executable information is read, or the user's It may be set in advance in the information processing apparatus 2 whether the pre-execution information is not executed and additional executable information is not read until an explicit instruction is received. This setting may be stored in a storage unit that does not volatilize when the information processing apparatus 2 is powered off.

  According to the present embodiment, the additional executable information is associated with the module that has not been rewritten among the executable information. Therefore, when performing a test, all the modules are linked again, and the entire object code after the link is performed. Need not be stored in the storage medium.

It is a block diagram showing the example of a structure of the additional executable information generation apparatus which concerns on embodiment of this invention. It is explanatory drawing showing the example of the general process of the compile / link by the additional executable information generation apparatus which concerns on embodiment of this invention. It is explanatory drawing showing the example of the map information which the additional executable information generation apparatus which concerns on embodiment of this invention produces | generates. It is a block diagram showing an example of an information processing apparatus according to an embodiment of the present invention. It is explanatory drawing showing the example of the content of the executable information which the additional executable information generation apparatus which concerns on embodiment of this invention produces | generates. It is a flowchart figure showing the production | generation processing example of the additional executable information by the additional executable information generation apparatus which concerns on embodiment of this invention. It is explanatory drawing showing the example of a relationship between the executable information produced | generated by the additional executable information production | generation apparatus which concerns on embodiment of this invention, and additional executable information. It is a flowchart figure showing the example of generation of the prior execution information by the additional executable information generating device concerning an embodiment of the invention. It is explanatory drawing showing the operation example of the additional executable information generation apparatus which concerns on embodiment of this invention. It is explanatory drawing showing another example of the additional executable information which the additional executable information generation apparatus which concerns on embodiment of this invention produces | generates.

Explanation of symbols

DESCRIPTION OF SYMBOLS 1 Additional executable information generation apparatus, 2 Information processing apparatus, 11, 22 Control part, 12, 23 Storage part, 13 Operation part, 14 Output part, 24 Interface part, 25 Function part.

Claims (2)

Storage means for associating and storing identification information of a call target included in computer-executable execution information fixed to a storage medium and a storage position in the storage medium;
Generating means for generating additional executable information including a processing instruction for calling a call target included in the execution information;
The execution information is rewritten when pre-execution information executed by a computer before execution of the execution information and the call target corresponding to the call target called by the execution information is included in the additional executable information And pre-execution information generation means for generating pre-execution information for setting to call the corresponding call target included in the additional executable information,
The generating means is
A call instruction element that refers to the information stored in the storage unit and calls the call target called by the processing instruction when the additional executable information to be generated includes a processing instruction that calls the call target in the execution information. Is generated, and the processing instruction is rewritten to an instruction for calling the storage position of the corresponding call instruction element, and is output together with the call instruction element.   Computer
  Storage means for associating and storing identification information of a call target included in computer-executable execution information fixed to a storage medium and a storage position in the storage medium;
  Generating means for generating additional executable information including a processing instruction for calling a call target included in the execution information;
  The execution information is rewritten when pre-execution information executed by a computer before execution of the execution information and the call target corresponding to the call target called by the execution information is included in the additional executable information A pre-execution information generating means for generating pre-execution information for setting to call the corresponding call target included in the additional executable information,
  When functioning as the generation means, the information stored in the storage means is referred to. When the additional executable information to be generated includes a processing instruction for calling a call target in the execution information, the processing instruction A program that generates a call instruction element that calls a call target to be called, rewrites the processing instruction into an instruction that calls a storage position of the corresponding call instruction element, and outputs the instruction together with the call instruction element.

Images