CN112579470B

CN112579470B - Compiling and linking method and system for debugging dynamic software library

Info

Publication number: CN112579470B
Application number: CN202011600048.8A
Authority: CN
Inventors: 徐顺; 刘倩; �金钟
Original assignee: Computer Network Information Center of CAS
Current assignee: Computer Network Information Center of CAS
Priority date: 2020-12-29
Filing date: 2020-12-29
Publication date: 2022-08-30
Anticipated expiration: 2040-12-29
Also published as: CN112579470A

Abstract

The invention belongs to the technical field of compiling and linking of software dynamic library debugging, and relates to a compiling and linking method and a compiling and linking system of software dynamic library debugging, wherein the method comprises the following steps: acquiring source code files needing to be repeatedly modified from the first group of source code files to form a second group of source code files; compiling and linking the first group of source code files to generate a first dynamic library link library; compiling and linking the second group of source code files to generate a second dynamic link library; and jointly linking the first dynamic link library and the second dynamic link library to generate the target executable program. The invention avoids the time-consuming process of generating a large-scale dynamic library, and finally improves the efficiency of the compiling and linking process of dynamic library debugging.

Description

Compiling and linking method and system for debugging dynamic software library

Technical Field

The invention relates to a compiling and linking technology for debugging a software dynamic library, in particular to a compiling and linking method and a compiling and linking system for debugging the software dynamic library.

Background

In software compiling, the dynamic library linking method is to compile partial modules of the software into library forms (such as Linux, so file and Windows, dll file, etc.) separately, and each independent dynamic library module is linked into the final executable software program. The dynamic link design mode of the software program is beneficial to sharing of a dynamic library among different software, the dynamic library provides a standard and uniform function interface and isolates the design of software running on an upper layer, and the function body can have different implementation modes as long as the function of the dynamic library keeps a function calling interface unchanged, and the running of the upper layer software cannot be changed. Referring to fig. 1, each source code file is compiled by a compiler to generate an object file, a linker links each object file into a dynamic link library, and finally an executable program calls the dynamic library in a dynamic loading mode, and the dynamic link library and the executable program can be separately and independently designed.

The dynamic library is usually generated by linking all the involved object files (e.g., o file under Linux and obj file under Windows) to finally generate a dynamic library file with a format specification. The process of linking involves the consolidation of global code and data by executable code segments, data blocks, etc. in the object file. But when linking to create large dynamic libraries, hundreds or thousands of object files need to be relied upon, and the entire process can become lengthy, even over half an hour. The biggest problem is that when the dynamic library is debugged, every time the source code of one object file is debugged and modified, the link process needs to perform layout arrangement on all the object files again, and the compiling and linking process is time-consuming. For the condition that the source code of the object file needs to be frequently modified during debugging, the whole debugging and compiling process is long and low in efficiency. Therefore, the conventional dynamic library linking method is not suitable for debugging and compiling large-scale dynamic libraries.

Disclosure of Invention

The invention aims to solve the technical problems that the large-scale program compiling and linking process is long in time consumption and the compiling and linking process efficiency is low due to the fact that a source code dependent on a dynamic library is debugged (frequently modified) in the conventional compiling method for debugging the dynamic library program.

In order to achieve the above object, in one aspect, the present invention provides a method for compiling and linking dynamic library debugging of software, including the following steps:

acquiring a source code file needing to be repeatedly modified from the first group of source code files to form a second group of source code files;

compiling and linking the first group of source code files to generate a first dynamic link library; compiling and linking the second group of source code files to generate a second dynamic link library;

and jointly linking the first dynamic link library and the second dynamic link library to generate the target executable program.

In another aspect, the present invention provides a system for compiling and linking dynamic library debugging of software, including:

the first generation unit is used for acquiring source code files needing to be repeatedly modified from the first group of source code files to form a second group of source code files;

the second generation unit is used for compiling and linking the first group of source code files to generate a first dynamic library; compiling and linking the second group of source code files to generate a second dynamic link library;

and the third generation unit is used for jointly linking the first dynamic link library and the second dynamic link library to generate the target executable program.

The method has the advantages that a small amount of files needing debugging are independently compiled, the number of files involved in general debugging is small, the compiling processes of the debugging files are faster than that of the whole file compiling process, the generation of a new dynamic library does not involve the modification of an original dynamic library, the original dynamic library does not need to be generated again, and the time-consuming process of generating a large-scale dynamic library is avoided. And finally, the efficiency of the compiling and linking process of dynamic library debugging is improved.

Drawings

FIG. 1 is a diagram illustrating a structure of a compiled link for debugging a dynamic library of software in the prior art;

fig. 2 is a schematic flowchart of a compiling and linking method for debugging a dynamic library of software according to an embodiment of the present invention;

FIG. 3 is a diagram illustrating a structure of a compiled link for debugging the dynamic library of the software shown in FIG. 2;

fig. 4 is a schematic structural diagram of a compiling and linking system for debugging a software dynamic library according to an embodiment of the present invention.

Detailed Description

The present invention will be described in further detail with reference to the accompanying drawings and specific embodiments.

Fig. 2 is a flowchart illustrating a compiling and linking method for debugging a dynamic library of software according to an embodiment of the present invention. As shown in fig. 2, the method for compiling and linking software dynamic library debugging includes the following steps:

step S101, acquiring a source code file needing to be repeatedly modified from a first group of source code files to form a second group of source code files;

specifically, as shown in fig. 3, the source code files (1, 2, … …, n) are code contents of a program, and the source code files (1, 2, … …, n) are compiled to form object files (1, 2, … …, n). One or more object files may be linked in the form of dynamically linked libraries, one or more of which are linked as executable programs.

In fig. 3, the content outside the left side frame is the first dynamic library link library process (i.e. shown in fig. 1), and the embodiment of the present invention obtains the source code files that need to be repeatedly modified from the first set of source code files (1, 2, … …, n) to form the second set of source code files (debug files). The embodiment can acquire the source code file needing to be repeatedly modified in a copying mode.

Step S102, compiling and linking a first group of source code files to generate a first dynamic link library; compiling and linking the second group of source code files to generate a second dynamic link library (new dynamic link library);

specifically, the embodiment of the present invention compiles the first set of source code files into object files (with "+" symbol after numbering in fig. 3), respectively, and then links them into the second dynamically linked library.

Step S103, the first dynamic link library and the second dynamic link library are linked together to generate a target executable program.

Preferably, the second dynamically linked library pathname is placed before the first dynamically linked library pathname in a command line parameter of the linking target executable. The second dynamically linked library has a higher priority than the first dynamically linked library.

In the embodiment of the invention, in the process of selecting the independent debugging file as a compiling unit, the compiling unit can be assisted by a make compiling tool and a cmake compiling tool, so that the make compiling tool and the cmake compiling tool output the used compiling command lines, and the dependent relation of the debugging file can be found in the command lines. For example, adding VERBOSE ═ 1 option to make command will output the compiling and linking process of each file.

An example process command line for a dynamic library linking approach is as follows:

CXX＝g++

and $ CXX a. cpp- -shared-fPIC-o liba. so// the first set of source code files are compiled into a first dynamic link library liba. so

So// a second set of source code files compiled as a second dynamic link library, so

The debugging function defined by $ { CXX } c.cpp-L. -lb-la-o c1ba// second dynamic link library libb. so has precedence over the first dynamic link library

$ CXX $ c. cpp libb. so liba. so-o c2ba// the second dynamically linked library takes precedence over the first dynamically linked library

./c1ba

./c2ba

In the above command line, the first set of source code files is a.cpp (usually multiple files), and is compiled into a first dynamic link library liba.so, and the debug file b.cpp is a copy modified version of the a.cpp, and the b.cpp generally defines only the debug function, and only contains part of the content in the a.cpp. The cpp is compiled as a second dynamic link library libb.so, and the main file c.cpp originally aims to call the debug function defined in the a.cpp, because the b.cpp also defines the debug function of the same interface, in an embodiment of the invention the debug function defined by the second dynamic link library libb.so (corresponding to b.cpp) is linked into the executable file generated by the c.cpp in preference to the first dynamic link library liba.so (corresponding to a.cpp), by placing libb.so before liba.so, or lb before la, in the command line parameters. In the embodiment of the invention, after the generated liba.so is generated once, the debugging process does not need to be modified, the modification is only carried out in b.cpp, and only the libb.so needs to be generated again. After debugging is completed, the modified content in the b.cpp can be merged into the a.cpp, so that the b.cpp and the libb.so are not needed any more, and the conventional compiling and linking mode is changed.

Fig. 4 is a schematic structural diagram of a compiling and linking system for debugging a software dynamic library according to an embodiment of the present invention. As shown in fig. 4, an embodiment of the present invention provides a system for compiling and linking dynamic library debugging of software, where the system includes: a first generation unit 41, a second generation unit 42, and a third generation unit 43.

A first generating unit 41, configured to obtain a source code file that needs to be repeatedly modified from a first group of source code files, and form a second group of source code files;

a second generating unit 42, configured to compile and link the first set of source code files, and generate a first dynamic library; compiling and linking the second group of source code files to generate a second dynamic link library;

a third generating unit 43, configured to link the first dynamic link library and the second dynamic link library together to generate a target executable program.

In the embodiment of the invention, individual source code files needing to be modified in debugging are independently compiled and linked into an independent new dynamic link library, and then the independent new dynamic link library and the original dynamic link library are linked together to generate the target executable program. When the two dynamic libraries are linked together, the key point is to ensure that the new dynamic link library covers a part of corresponding function interfaces in the source dynamic library, so that the executable file calls the realization function of the debugging function in the new dynamic library instead of the corresponding debugging function in the original dynamic library. The time-consuming process of generating the large-scale dynamic library is avoided, and the efficiency of the compiling and linking process of dynamic library debugging is finally improved.

It will be obvious that many variations of the invention described herein are possible without departing from the true spirit and scope of the invention. Accordingly, all changes which would be obvious to one skilled in the art are intended to be included within the scope of this invention as defined by the appended claims. The scope of the invention is only limited by the claims.

Claims

1. A compiling and linking method for debugging a software dynamic library is characterized by comprising the following steps:

acquiring a source code file needing to be repeatedly modified from the first group of source code files in a copying and modifying mode to form a second group of source code files;

compiling and linking the first group of source code files to generate a first dynamic link library; compiling and linking the second group of source code files or the modified second group of source code files to generate a second dynamic link library;

2. The method of claim 1, wherein the second dynamically linked library pathname is placed before the first dynamically linked library pathname in a command line parameter of a linking target executable program.

3. The method of claim 1, wherein the second dynamically linked library has a higher priority than the first dynamically linked library.

4. The method of claim 1, wherein the compilation tools make use of make and cmake to output the compilation command lines used to find the dependencies of the debug files.

5. A system for compiling and linking dynamic library debugging of software, comprising:

the first generation unit is used for acquiring a source code file needing to be repeatedly modified from the first group of source code files in a copying and modifying mode to form a second group of source code files;

the second generation unit is used for compiling and linking the first group of source code files to generate a first dynamic library; compiling and linking the second group of source code files or the modified second group of source code files to generate a second dynamic link library;

6. The system of claim 5, wherein the second dynamically linked library pathname is placed before the first dynamically linked library pathname in a command line parameter of a linking target executable program.

7. The system of claim 5, wherein the second dynamically linked library has a higher priority than the first dynamically linked library.

8. The system of claim 5, wherein the assistance of make and cmake compilation tools causes them to output the compilation command lines used, in which the dependencies of debug files can be found.