KR101548960B1 - Method for making and debuging program using virtual platform and appparatus therof - Google Patents

Abstract

The present invention relates to a program creation and debugging method and apparatus using a virtual platform, and more particularly, to a program creation and debugging method using a virtual platform, comprising arranging and linking code and data included in an object file, Loading the executable loadable file into a first memory of the virtual platform; executing a simulation based on the loaded executable loadable file; if the modification of the program is required as a result of the simulation, Generating a link-type object including information necessary for execution, and loading the generated link-type object into a second memory of the virtual platform, and executing a re-simulation.

Virtual platforms, executable loadable files, debug links, linked objects

Description

[0001] METHOD FOR MAKING AND DEBUGING PROGRAM USING VIRTUAL PLATFORM AND APPARATUS THEROF [0002]

The present invention relates to a program creation and debugging method and apparatus using a virtual platform. More specifically, in the present invention, when a created source file is to be modified, the linked object file generated by compiling the modified source file and the previously created executable loadable file are loaded into independent memories, respectively, Can be executed.

A virtual platform is a platform configured to execute simulation on a PC rather than actual hardware. In this case, various virtual platforms can be easily created by implementing each component using a high-level language.

In the conventional programming method of the virtual platform, simulation was performed using binary information generated by modifying the program, compiling and linking steps when analyzing program development and platform performance and structure. In this case, if the program is rewritten or modified, the compile and link steps must be repeated. In particular, as the size of the program increases and the number of source files increases, you will have to recompile and link again, despite minor program modifications. Also, if the function in the modified source file is used in another source file, it takes a lot of time to recompile and link all the related source files.

Therefore, there is a need for a method for writing and debugging a program that can reduce compilation and link execution time and efficiently perform debugging in the process of writing a program and modifying the program.

SUMMARY OF THE INVENTION The present invention has been made to solve the above problems, and it is an object of the present invention to provide a program creation method capable of efficiently modifying and debugging a program in a virtual platform.

It is still another object of the present invention to provide a virtual platform having an independent memory capable of loading a linked object file generated by compiling a modified source file and a previously created executable loadable file .

According to an embodiment of the present invention, there is provided a method of creating and debugging a program using a virtual platform, the method comprising: arranging and linking code and data included in an object file; Loading the loaded executable loadable file into the first memory, executing a simulation based on the loaded executable loadable file, and if a modification of the program is required as a result of the simulation, Type object, and loading the generated link-type object into the second memory of the virtual platform, and executing the re-simulation. In this case, the step of executing the re-simulation may include switching, when using the modified information, access to the executable loadable file loaded in the first memory to access to the linked object loaded in the second memory And the link is a debug link that allocates and links a usable reservation area to code and data included in the object file.

An apparatus for creating and debugging a program using a virtual platform of the present invention includes an executable loadable file generation unit for arranging and linking code and data included in an object file and generating the executable loadable file by the link, And a memory access control unit for controlling selective access to the executable loadable file and the link type object, wherein the link type object generation unit generates a link type object including information necessary for execution of simulation by compiling the source file, A control unit, a first memory in which the executable loadable file is loaded, a second memory in which the linked object is loaded, and an executable loadable file and an object remapping unit for switching selective access to the linked object . In this case, the link is a debug link that allocates and arranges a usable reserved area for code and data contained in an object file, and the link-type object refers to information included in the executable loadable file .

Using the program creation method and the virtual platform according to the embodiment of the present invention, the simulation can be executed using only the linked object file generated by compiling only the modified source file and the pre-generated executable loadable file without a separate link process So you can shorten program modification and debugging time.

Particularly, the program creation method and the virtual platform according to the embodiment of the present invention can further shorten the debugging time with a program having a large number of source files and a large file size.

In the present invention, a load means that a stored program or data is read and stored in a memory.

In the present invention, the re-simulation means that the simulation is executed again after the source file is modified.

Hereinafter, preferred embodiments of the present invention will be described in detail with reference to the accompanying drawings. Note that, in the drawings, the same components are denoted by the same reference symbols as possible. Further, the detailed description of well-known functions and constructions that may obscure the gist of the present invention will be omitted.

1 is a schematic diagram showing a process of executing a simulation using an execution loadable file (ELF) generated before a code modification and a linked object generated after a code modification in a virtual platform according to an embodiment of the present invention .

<Before modifying code>

First, it is assumed that the programmer has created the first source file and the second source file. In this case, the first source file includes function A and function B, and the second source file includes function C and function D. The created first and second source files are compiled by the compiler. In this case, a compiler can be defined as a program that processes a sentence written in a specific programming language and changes it into a code that can be used by a machine language or a computer.

When the first and second source files are compiled, the first source file is converted into a first object file, and the second source file is converted into a second object file. After the compiling process, the first and second object files are linked. The linking process can be defined as a process of determining relative positions of an instruction or data when one or more object modules are executed simultaneously and when they mutually refer to each other's instruction or data. In other words, when an arbitrary function calls a function or a variable in another file, only the indication as to which function or variable is referred to in the object file is recorded in the compilation process. The process of eliminating the dependency of such object files is a link process . According to an embodiment of the present invention, the link may be performed by a debug link process of arranging object files and data in consideration of reserved areas when arranging objects.

When the first and second object files pass through the link process, an Executable and Loadable File (ELF) that can be executed in the virtual platform is generated. In this case, the executable loadable file includes executable binaries, location of sections, information necessary for executing binaries such as debugging information, additional information, and relocation information.

The executable loadable file generated through the compiling and linking process is loaded into the first memory when the simulation is executed.

<After modifying the code>

If a program error occurs or there is a need to change the function contents after execution of the simulation using the executable loadable file generated through the above process, the programmer re-creates or modifies the source file and executes the simulation again This process is called debugging.

In the present invention, it is assumed that the function B of the first source file created before the code modification needs to be modified to the function BB. According to the conventional debugging process, there is a need to recompile the first and second source files after modifying the function BB, and relink the generated first and second object files.

However, according to the present invention, if a function B of the first source file is modified to a function BB and a linked compile according to an embodiment of the present invention is performed, a first linked object file . In this case, the link-type first object file is independent of the executable loadable file generated in the step before the code modification, and the linkable compilation process does not change the executable loadable file (ELF).

When the simulation is executed (without a separate link process), the pre-generated executable loadable file (ELF) is loaded into the first memory, and the link-type first object file Is loaded.

When the modified function BB needs to be used after execution of the simulation, access to the executable loadable file (ELF) loaded in the first memory is switched to access to the linked first object file loaded in the second memory switch. In this case, the link-type first object file loaded in the second memory is not performed independently but the binary information of the executable loadable file (ELF) loaded in the first memory is referred to so that the simulation can be executed.

The link-type first object file generated by link-compiling the modified first source file can be executed by referring to the information of the execution loadable file (ELF) in the previous step without going through a separate link process It is.

2 is a block diagram illustrating an internal structure of a virtual platform capable of loading and simulating a plurality of object files according to an embodiment of the present invention. In this case, the virtual platform may include a BUS 210, a first memory 220, a second memory 230, an object remapping unit 240, and a controller 250.

The BUS 210 is a line used for transferring signals between individual blocks or between external devices constituting the virtual platform of the present invention. Generally, a bus to which a data signal is transmitted is called a data bus, and a bus to which an address is transmitted is called an address bus.

The first memory 220 stores programs and data necessary for the overall operation of the virtual platform according to the embodiment of the present invention. In the first memory 220, an execution loadable file (ELF) generated by a compile and debug link before code modification can be loaded at the time of simulation execution.

The second memory 230 is a self-memory of the virtual platform for driving the virtual platform according to the embodiment of the present invention. The second memory 230 is only accessible by the object remapping unit 240. When a link is compiled after the code is modified, a linked object is created. When the simulation is executed, the linked object file is loaded into the second memory 230. In other words, when the programmer executes the simulation after the code modification, the execution loadable file (ELF) generated in the stage before the code modification is stored in the first memory 220, the linked object file generated in the step after the code modification is stored in the second memory (230).

The object remapping unit 240 performs functions such as a function existing in an executable loadable file (ELF) loaded in the first memory 230 and a linked object file loaded in the second memory 240, Control access to data. In other words, when the control unit 250 executes an instruction or loads data, it has to access the first memory 220 or the second memory 230. In order to access the modified function in the step after the code modification, The access to the executable loadable file ELF of the memory 220 should be switched to the access to the linked object file of the second memory 230. [ In this case, the programmer can set whether to access a function in a script format, and the object remapping unit 240 controls access to the linked object file in the second memory 230 according to the user setting.

The control unit 250 is a central processing unit for controlling the virtual platform of the present invention, and may be a central processing unit (CPU) in the embodiment of the present invention, and performs a logical operation and a central control function. According to an embodiment of the present invention, the controller 250 may include an executable loadable file generator 250A, a linked object file generator 250B, and a memory access controller 250C.

The control unit 250 controls a series of processes for executing a simulation without a link process when a source file created by a programmer is to be modified.

The executable loadable file generation unit 250A can control the compiling step when the initial source file is created. In addition, the executable loadable file generation unit 250A executes a debug link in a link process for simulating the compiled and generated object files to control execution loadable files to be generated. The debug link means arranging the object file and the data in consideration of the reserved area when arranging the objects in the link step. A specific example of such a debug link is shown in FIG.

As can be seen from FIG. 3, the executable loadable file generation unit 250A does not arrange the object files and the object data in succession in the link process of the present invention, as in the general link process, And allocates a reserved area for object codes and object data of the object codes. That is, the executable loadable file creating unit 250A is configured such that the first object file 310 is a reserved area 310A, the second object file 320 is a reserved area 320A, the third object file 330 is A debug link is executed so that the first object data 340 includes the reserved area 340A and the second object data 350 includes the reserved area 350A. In this case, the debug link proposed in the present invention does not cause a separate time delay in performing the link process.

In this case, the first object file 310 and the reserved area 320A may have reserved areas for respective functions. In other words, the function a 312 may have a reserved area 312A and the function b 314 may have a reserved area 314A separately. However, according to another embodiment of the present invention, as described above, each function does not have a reserved area separately, but all functions may have a common reserved area.

If the size of the modified function is larger than the size of the function before modification, the function may invade other functions or other data areas during compilation and linking, causing a collision when executing the simulation. . However, in the debug link process according to the present invention, since a separate reserved area is allocated to each object, if the size of the modified function is larger than the size of the unmodified function, a pre-allocated reserved area can be used. The problem of invasion does not occur.

The linked object file generation unit 250B controls the step of generating a linked object for the modified source file through a linked compile. In this case, the link type object file is a code independent from the executable loadable file (ELF) generated in the step before the code modification as described above, but can not be independently executed, Means a file that should be referred to.

The memory access control unit 250C obtains information about functions that need to convert a call of the pre-modification function to a call of a function. When access to the changed function is requested, the memory access controller 250C controls the object remapping unit 240 to access the executable load file (ELF) of the first memory in the linked object of the second memory Lt; / RTI &gt;

4 is a flowchart illustrating a process of creating and modifying a program using a virtual platform according to an embodiment of the present invention.

First, when a source file is created in step S405, the created source file is compiled in step S410. When the compilation step is executed, the source file is converted into an object file containing information about the machine language or code that the computer can use. The object file generated after the compiling process is converted into an executable loadable file (ELF) in step S420 through a debug link process in step S415.

In this case, the debug link process executed in step S415 means allocating a reserved area for each object file and object data, and arranging them. Even if the size of the function after the program modification is increased due to the reserved area, it may cause a problem of invading another function or data area.

Once an Executable Loadable File (ELF) is generated, a simulation through the virtual platform can be executed. That is, when the simulation is executed in step S425, the generated executable loadable file ELF is loaded into the first memory 220. [ Then, the control unit 250 accesses the executable loadable file (ELF) loaded in the first memory and executes a command or loads data.

Simulation results through the virtual platform are output in step S430. The control unit 250 determines whether the program created in step S435 is changed or modified. If the program is changed or modified, the controller 250 controls the program modification and execution process in step S440.

However, if the program is not changed or modified, the control unit 250 controls a series of processes for generating an executable loadable file (ELF) to be finally executed. That is, the controller 250 executes a compilation process on the finally confirmed source files in step S445. When the compilation is executed, an object file is created for each source file.

In step S450, the controller 250 executes a link process on the object files. The link process executed in step S450 is different from the debug link process executed in step S415. In other words, in step S415, the debug link process allocates a reserved area for the object file and the object data on the premise of debugging at a later stage. On the other hand, since debugging has already been completed in step S450, It is not necessary to allocate the reserved area of the &lt; / RTI &gt; When the link process is completed, an execution loadable file to be finally simulated is generated in step S455.

5 is a flowchart illustrating a process of debugging using a virtual platform according to an embodiment of the present invention.

First, the program created in FIG. 4 is modified or changed in step S510. After modifying the program, the control unit 250 executes a linked complication on the modified source file in step S515. Conventionally, even if only one source file is modified, a process of recompiling and linking all the source files is required for simulation, and therefore, there is a problem that unnecessary time is consumed. However, according to the embodiment of the present invention, only the modified source file is compiled. Such compilation is called link-type compilation. When the control unit 250 performs link type compilation, the modified source file is converted into a linked object in step S520.

In step S525, the control unit 250 receives information about functions that need to switch access to the executable loadable file (ELF) to access to the linked object, and transfers the information to the object remapping unit 240. [ In this case, it is necessary to decide what to use for functions and data that exist simultaneously in the executable loadable file (ELF) and the linked object, and whether to access the executable loadable file to the linked object Information about functions that need to be switched to access can be entered individually or in batches using a script.

Then, the controller 250 executes the simulation in step S530. In this case, in step S535, the controller 250 loads the execution loadable file ELF generated in step S420 into the first memory 220 and loads the linked object generated in step S520 into the second memory 230 .

Hereinafter, steps S525 and S530 will be described in more detail. For example, if function A and function B are created in the program modification source file, the information is included in the executable loadable file (ELF) generated by the initial compilation and linking process. If the function B is changed to the function BB by the program modification, a linked object including the function A and the function BB is generated by link-type compilation according to the embodiment of the present invention. When the simulation is executed, the execution loadable file ELF is loaded into the first memory 220 and the linked object is loaded into the second memory 230. When the simulation is executed, the object remapping unit 240 accesses the function B of the executable loadable file (ELF) loaded in the first memory 220 based on the information received from the control unit 250 in step S525, To the function BB of the linked object loaded into the function block 230. [

In summary, in the virtual platform of the present invention, the executable loadable file (ELF) generated before the program modification and the link-type object converted by the link-type compilation are independently loaded into a separate memory and simulated. Therefore, the modified source file can be executed by referring to the existing executable loadable file (ELF) generated, so there is no need for a separate link process, and the unedited source file does not need to be recompiled, You can do it.

Simulation results through the virtual platform are output in step S540. The control unit 250 determines whether the program created in step S545 is changed or modified. If the program is changed or modified, the controller 250 controls the execution of steps S510 through S540.

However, if the program is not changed or modified, the control unit 250 controls a series of processes for generating an executable loadable file (ELF) to be finally executed. That is, the control unit 250 executes the compiling process for the finally confirmed source files in step S555. When the compilation is executed, an object file is created for each source file.

In step S555, the controller 250 executes a link process on the object files. The link process executed in step S450 is different from the debug link process executed in step S415 as described above. When the link process is completed, an execution loadable file (ELF) to be finally simulated is generated in step S560.

Hereinafter, the time required for performing the conventional program creation and debugging process and the time required for performing the program creation and debugging according to the embodiment of the present invention are compared.

First, assume that there are three files: a first source file, a second source file, and a third source file. It is assumed that the first source file needs to be modified.

&Lt; Time required for simulation by the conventional method >

First, in order to execute the simulation in the virtual platform using the above-described source files, the respective source files must be compiled. In this case, the time to compile is tc (1), tc (2), tc (3), respectively. The time taken to link each object file created and compiled is Tlink.

Then, the final time from link to compile is as shown in Equation 1 below.

[Equation 1]

Ttot = tc (1) + tc (2) + tc (3) + Tlink

The time required for correcting the first source file, i.e., the debugging time, is expressed by Equation 2 below.

&Quot; (2) &quot;

Tdebug = tc (1) + Tlink = Ttot

The debugging process frequently occurs at the time of program development. If n program modifications occur, the final time excluding the simulation time is expressed by Equation 3 below.

&Quot; (3) &quot;

Tfinish = Ttot + n * Tdebug = Ttot + n * tc (1) + n * Tlink

<Time required for simulation according to the embodiment of the present invention>

In the method proposed in the present invention, as in the conventional method, in order to execute the simulation in the virtual platform, a compile and debug link process should be executed for the first source file, the second source file, and the third source file. In this case, the time to compile is tc (1), tc (2), tc (3), respectively. And the time taken to debug link each object file created by compilation is Tlink. The present invention differs from the conventional method in that each compiled object file executes a debug link process rather than a general link. In this case, the debug link arranges the code and data of the object file in consideration of the reserved area, but does not affect the link time.

Then, the final time from the link to the compile-time is expressed by Equation (4) below, which is the same as Equation (1).

&Quot; (4) &quot;

Ttot = tc (1) + tc (2) + tc (3) + Tlink

The time until the first source file is modified and the link type compilation is executed, that is, the execution loadable file capable of executing the simulation again, and the time until the link type object is generated, is expressed by Equation (5).

&Quot; (5) &quot;

Tdebug = tc (1)

In other words, it only takes time for the modified first source file to be linked compiled.

If n debugging processes are performed in the program development stage, the time required for n debugging processes is expressed by Equation (6) below.

&Quot; (6) &quot;

Tfinish_tmp = Ttot + n * Tdebug = Ttot + n * tc (1)

After completing the debugging process, the time required to generate an executable loadable file (ELF) to be finally used is expressed by Equation (7) below.

&Quot; (7) &quot;

Tfinish = Tfinish_tmp + Ttot = 2 * Ttot + n * Tdebug

Comparing Equation (3) according to the conventional method with Equation (7) according to the embodiment of the present invention, the number of times of debugging, that is, the time n until the final program is completed, Value. &Lt; / RTI &gt; Particularly, since the number of occurrences of n increases as the program debug and structure analysis and performance analysis become complicated, and the link time becomes longer as the number and size of the source files increase, You can.

The embodiments of the present invention disclosed in the present specification and drawings are merely illustrative of specific embodiments of the present invention and are not intended to limit the scope of the present invention in order to facilitate understanding of the present invention. It will be apparent to those skilled in the art that other modifications based on the technical idea of the present invention are possible in addition to the embodiments disclosed herein.

FIG. 1 is a schematic diagram showing a process of executing a simulation using an execution loadable file (ELF) generated before a code modification and a linked object created after a code modification in a virtual platform according to an embodiment of the present invention.

2 is a block diagram illustrating an internal structure of a virtual platform capable of loading and simulating a plurality of object files according to an embodiment of the present invention;

3 is a diagram illustrating a specific example of a debug link according to an embodiment of the present invention;

4 is a flowchart illustrating a process of creating and modifying a program using a virtual platform according to an embodiment of the present invention;

5 is a flowchart illustrating a process of debugging using a virtual platform according to an embodiment of the present invention.

Claims (14)

A method for creating and debugging a program using a virtual platform, Generating an executable loadable file through a debug link that allocates and arranges a reserved area for code and data contained in an object file; Loading the executable loadable file into a first memory of the virtual platform; Executing a simulation based on the loaded executable loadable file; If it is necessary to modify the program as a result of the simulation, compiling only the modified source file after the modification of the source file to generate a linked object including information necessary for executing the simulation; And Loading the generated linked object into a second memory of the virtual platform to execute a re-simulation, Wherein the reserved area is allocated to prevent collision caused by invading another data area when creating the linked object. The method according to claim 1, Wherein the step of executing the re-simulation switches access to the executable loadable file loaded in the first memory to access to the linked object loaded in the second memory when the modified information is used A method for creating and debugging a program using a virtual platform. delete The method according to claim 1, Wherein the link-type object is executed by referring to the information included in the executable loadable file during the re-simulation. 5. The method of claim 4, Wherein the first memory and the second memory are independent memories independent of each other. The method according to claim 1, Compiling the completed source file to generate an object file upon completion of program modification; And And generating a final executable loadable file by linking the generated object file. &Lt; Desc / Clms Page number 19 &gt; The method according to claim 1, Wherein the step of generating the linked object further comprises the step of inputting information about functions that need to switch access to the executable loadable file to access to the linked object. How to create and debug a program using. 8. The method of claim 7, Wherein the input of information on the functions to be switched is input using a script. An executable loadable file generation unit for generating an executable loadable file through a debug link that allocates and arranges a separate reserved area for code and data contained in an object file; A link type object generation unit that compiles only the modified source file and generates a link type object including information necessary for executing a simulation, and a memory access control unit that controls selective access to the executable load file and the link type object ; A first memory in which the executable loadable file is loaded; A second memory in which the linked object is loaded; And An executable loadable file and an object remapping unit for switching selective access to the linked object, Wherein the reserved area is allocated to prevent collision caused by invading another data area when creating a linked object. delete 10. The method of claim 9, Wherein the link type object is executed by referring to the information included in the execution loadable file at the time of the simulation. 12. The method of claim 11, Wherein the first memory and the second memory are independent memories independent of each other. 10. The method of claim 9, Wherein the control unit compiles the completed source file to generate an object file and links the generated object file to generate a final executable loadable file when the program modification is completed. And a debugging device. 10. The method of claim 9, Wherein the memory access controller receives input of information about functions that need to be switched as a script.

Images