Static library file processing method and related equipment

Abstract

The invention provides a static library file processing method and related equipment. The method comprises the steps of obtaining a to-be-processed first static library file and a corresponding header file; generating a second static library file including a preset operation based on the header file; and combining the first static library file and the second static library file to obtain a target static library file.

Description

Technical Field

[0001] The present disclosure relates to the field of computer technology, and in particular to a method for processing static library files and related devices. Background Art

[0002] Static library files are linked into the program during compilation and become part of the executable file. This makes it impossible to extend the functionality of static library files by intercepting them. Instead, the only option is to modify the static library code, which increases the complexity of application development and reduces development efficiency. Summary of the Invention

[0003] The present disclosure proposes a static library file processing method and related equipment to solve, to a certain extent, technical problems such as the inability to expand the functions of static library files by intercepting static library files, resulting in increased application development complexity and reduced development efficiency.

[0004] In a first aspect, the present disclosure provides a method for processing a static library file, comprising:

[0005] Obtain a first static library file to be processed and a corresponding header file;

[0006] Generate a second static library file including preset operations based on the header file;

[0007] The first static library file and the second static library file are merged to obtain a target static library file.

[0008] In a second aspect of the present disclosure, a device for processing static library files is provided, comprising:

[0009] An acquisition module is used to acquire a first static library file to be processed and a corresponding header file;

[0010] A generating module, configured to generate a second static library file including preset operations based on the header file;

[0011] A merging module is used to merge the first static library file and the second static library file to obtain a target static library file.

[0012] In a third aspect of the present disclosure, an electronic device is provided, comprising one or more processors, a memory; and one or more programs, wherein the one or more programs are stored in the memory and executed by the one or more processors, and the programs include instructions for executing the method described in the first aspect.

[0013] According to a fourth aspect of the present disclosure, a non-volatile computer-readable storage medium containing a computer program is provided. When the computer program is executed by one or more processors, the processors are caused to execute the method described in the first aspect.

[0014] In a fifth aspect of the present disclosure, a computer program product is provided, comprising computer program instructions, which, when executed on a computer, enable the computer to execute the method described in the first aspect.

[0015] From the above description, it can be seen that the present disclosure provides a method for processing a static library file and related equipment, which generates a second static library file including preset operations based on the header file of the first static library file, and merges the first static library file and the second static library file to obtain a target static library file. The first static library file can be intercepted through the second static library file to expand the function of the first static library file, thereby improving the development efficiency of applications that call the first static library file. BRIEF DESCRIPTION OF THE DRAWINGS

[0016] In order to more clearly illustrate the technical solutions in the present disclosure or related technologies, the following briefly introduces the drawings required for use in the embodiments or related technical descriptions. Obviously, the drawings described below are only embodiments of the present disclosure. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying any creative work.

[0017] Figure 1 Schematic diagram of the processing architecture of static library files according to an embodiment of the present disclosure.

[0018] Figure 2 Schematic diagram of the hardware structure of an exemplary electronic device according to an embodiment of the present disclosure.

[0019] Figure 3 This is a schematic flowchart of a method for processing static library files according to an embodiment of the present disclosure.

[0020] Figure 4 Schematic diagram of a method for processing static library files according to an embodiment of the present disclosure.

[0021] Figure 5 Schematic diagram of a static library file processing device according to an embodiment of the present disclosure. DETAILED DESCRIPTION

[0022] In order to make the objectives, technical solutions and advantages of the present disclosure more clearly understood, the present disclosure is further described in detail below in conjunction with specific embodiments and with reference to the accompanying drawings.

[0023] It should be noted that, unless otherwise defined, the technical terms or scientific terms used in the embodiments of the present disclosure should have the usual meanings understood by people with ordinary skills in the field to which the present disclosure belongs. The "first", "second" and similar words used in the embodiments of the present disclosure do not indicate any order, quantity or importance, but are only used to distinguish different components. "Include" or "comprise" and similar words mean that the elements or objects appearing before the word include the elements or objects listed after the word and their equivalents, without excluding other elements or objects. "Connect" or "connected" and similar words are not limited to physical or mechanical connections, but may include electrical connections, whether direct or indirect. "Up", "down", "left", "right" and the like are only used to indicate relative position relationships. When the absolute position of the described object changes, the relative position relationship may also change accordingly.

[0024] It is understandable that before using the technical solutions disclosed in the various embodiments of this disclosure, the type, scope of use, usage scenarios, etc. of the personal information involved in this disclosure should be informed to the user and the user's authorization should be obtained in an appropriate manner in accordance with relevant laws and regulations.

[0025] For example, in response to a user's active request, a prompt message is sent to the user to clearly inform the user that the operation requested will require the acquisition and use of the user's personal information. This allows the user to independently choose whether to provide personal information to the electronic device, application, server, storage medium, or other software or hardware that performs the operations of the disclosed technical solution based on the prompt message.

[0026] As an optional but non-limiting implementation, in response to receiving a user's active request, the prompt information may be sent to the user in the form of a pop-up window, in which the prompt information may be presented in text form. Furthermore, the pop-up window may also contain a selection control for the user to select "agree" or "disagree" to provide personal information to the electronic device.

[0027] It is understandable that the above notification and user authorization process are merely illustrative and do not limit the implementation of the present disclosure. Other methods that comply with relevant laws and regulations may also be applied to the implementation of the present disclosure.

[0028] Figure 1 Schematic diagram showing the processing architecture of static library files according to an embodiment of the present disclosure. Figure 1The processing architecture 100 of the static library file may include a server 110, a terminal 120, and a network 130 that provides a communication link. The server 110 and the terminal 120 may be connected via a wired or wireless network 130. The server 110 may be an independent physical server, or a server cluster or distributed system composed of multiple physical servers, or a cloud server that provides basic cloud computing services such as cloud services, cloud databases, cloud computing, cloud functions, cloud storage, network services, cloud communications, middleware services, security services, and CDN.

[0029] Terminal 120 can be implemented in hardware or software. For example, when implemented in hardware, terminal 120 can be any electronic device with a display screen that supports page display, including but not limited to smartphones, tablet computers, e-book readers, laptop computers, and desktop computers. When terminal 120 is implemented in software, it can be installed in the electronic devices listed above; it can be implemented as multiple software or software modules (such as software or software modules used to provide distributed services), or it can be implemented as a single software or software module, and no specific limitations are given here.

[0030] It should be noted that the static library file processing method provided in the embodiment of the present application can be executed by the terminal 120 or by the server 110. It should be understood that Figure 1 The number of terminals, networks, and servers in the embodiment is for illustration only and is not intended to limit the number of terminals, networks, and servers.

[0031] Figure 2 FIG. 2 shows a schematic diagram of the hardware structure of an exemplary electronic device 200 provided in an embodiment of the present disclosure. Figure 2 As shown, electronic device 200 may include: processor 202, memory 204, network module 206, peripheral interface 208 and bus 210. Processor 202, memory 204, network module 206 and peripheral interface 208 are connected to each other through bus 210 in communication with each other within electronic device 200.

[0032] The processor 202 may be a central processing unit (CPU), a processor with static library files, a neural network processor (NPU), a microcontroller (MCU), a programmable logic device, a digital signal processor (DSP), an application specific integrated circuit (ASIC), or one or more integrated circuits. The processor 202 may be used to perform functions related to the technology described in this disclosure. In some embodiments, the processor 202 may also include multiple processors integrated into a single logical component. For example, Figure 2 As shown, the processor 202 may include a plurality of processors 202a, 202b, and 202c.

[0033] The memory 204 may be configured to store data (eg, instructions, computer code, etc.). Figure 2 As shown, the data stored in the memory 204 may include program instructions (for example, program instructions for implementing the processing method of the static library file of the embodiment of the present disclosure) and data to be processed (for example, the memory may store configuration files of other modules, etc.). The processor 202 may also access the program instructions and data stored in the memory 204, and execute the program instructions to operate on the data to be processed. The memory 204 may include a volatile storage device or a non-volatile storage device. In some embodiments, the memory 204 may include a random access memory (RAM), a read-only memory (ROM), an optical disk, a magnetic disk, a hard disk, a solid-state drive (SSD), a flash memory, a memory stick, etc.

[0034] The network module 206 can be configured to provide the electronic device 200 with communication with other external devices via a network. The network can be any wired or wireless network capable of transmitting and receiving data. For example, the network can be a wired network, a local wireless network (e.g., Bluetooth, WiFi, near field communication (NFC)), a cellular network, the Internet, or a combination thereof. It will be appreciated that the type of network is not limited to the specific examples above. In some embodiments, the network module 306 can include any number of network interface controllers (NICs), radio frequency modules, transceivers, modems, routers, gateways, adapters, cellular network chips, and the like.

[0035] The peripheral interface 208 can be configured to connect the electronic device 200 to one or more peripheral devices to implement information input and output. For example, the peripheral devices can include input devices such as a keyboard, a mouse, a touchpad, a touch screen, a microphone, and various sensors, and output devices such as a display, a speaker, a vibrator, and an indicator light.

[0036] The bus 210 can be configured to transmit information between the various components of the electronic device 200 (e.g., the processor 202, the memory 204, the network module 206, and the peripheral interface 208), such as an internal bus (e.g., a processor-memory bus), an external bus (USB port, PCI-E bus), etc.

[0037] It should be noted that although the architecture of the electronic device 200 shown above only shows the processor 202, the memory 204, the network module 206, the peripheral interface 208, and the bus 210, in a specific implementation, the architecture of the electronic device 200 may also include other components necessary for normal execution. In addition, it will be understood by those skilled in the art that the architecture of the electronic device 200 may also include only the components necessary to implement the embodiments of the present disclosure, and does not necessarily include all the components shown in the figure.

[0038] A static library is a software library containing reusable code that is linked into a program during compilation. The executable code in a static library is copied into the final executable file of the main program during compilation, becoming part of the executable file, providing faster startup times and better performance. However, this also consumes more disk space and memory, and updating the library requires recompiling the entire main program. Dynamic libraries are loaded during runtime by the main program, saving disk space and facilitating updates, but with some additional loading time and performance overhead. Because dynamic libraries are loaded at runtime, they can be intercepted to add additional functionality based on the loading process. Static libraries, however, lack this dynamic loading feature, making it impossible to intercept static library files in a similar manner to add functionality. Functionality can only be expanded by updating the static library code. This increases application development complexity and reduces efficiency. Therefore, how to intercept static library files to expand their functionality, reduce the development complexity of applications that call static library files, and increase development efficiency has become a pressing technical challenge.

[0039] In view of this, embodiments of the present disclosure provide a method and related device for processing static library files. A second static library file including preset operations is generated based on a header file of a first static library file, and the first and second static library files are merged to obtain a target static library file. The second static library file can intercept the first static library file to expand the functionality of the first static library file, thereby improving the development efficiency of applications that call the first static library file.

[0040] See also Figure 3 , Figure 3The schematic flow chart of the method for processing static library files according to the embodiment of the present disclosure is shown. The method for processing static library files according to the embodiment of the present disclosure can be deployed on a server or a terminal. Figure 3 In the static library file processing method 300, the static library file processing method 300 may further include the following steps.

[0041] In step S310 , a first static library file to be processed and a corresponding header file are obtained.

[0042] A static library file can be a compiled target file containing at least one function and data structure, which can be shared and reused by multiple applications. A header file can contain declarations of functions, classes, and variables in a static library file, which are used to generate an executable file during compilation. Figure 4 , Figure 4 A schematic diagram of a method for processing static library files according to an embodiment of the present disclosure is shown. Figure 4 In the example, the first static library file libfoo.a may include at least one interface foo.o:_foo, bar.o:_bar, baz.o:_baz, and its corresponding header files include foo.h, bar.h, baz.h.

[0043] In step S320, a second static library file including preset operations is generated based on the header file.

[0044] The preset operation may refer to an operation that implements a preset function, such as implementing an extended function of the first static library file. The second static file may encapsulate the preset operation and have a corresponding interface with the first static library file. In this way, the first static library file can be intercepted by the second static library file to extend the preset function; and the first static library file can be connected to the second static library file to execute the first static library file. In this way, the function of the first static library file is extended without affecting the execution of the first static library file and without changing the code of the first static library file.

[0045] In some embodiments, generating a second static library file including preset operations based on the header file includes:

[0046] Generate an encapsulation interface file based on the header file and a preset code, wherein the preset code is used to implement the preset operation;

[0047] The encapsulation interface file is compiled to obtain the second static library file.

[0048] The interface information of the first static library file can be obtained based on the header file, and the second static library file generated based on the interface information has an interface corresponding to the first static library file. The preset code that implements the preset operation is encapsulated in the interface file and compiled into the second static library file. The second static library file can intercept the first static library file to expand the functionality of the first static library file.

[0049] In some embodiments, generating a package interface file based on the header file and the preset code includes:

[0050] Analyze the header file to obtain interface information of the static library file;

[0051] The encapsulated interface file is generated based on the interface information and the preset code, and the encapsulated interface file is consistent with the signature information of the interface information.

[0052] Among them, the interface can refer to a defined function or method for implementing a specific function. The header file can be parsed to obtain interface information, such as a syntax tree and other information describing the interface. Based on the interface information and the preset code, a hook function can be used to generate an encapsulated interface file that corresponds one-to-one to the interface of the first static library file and has consistent signature information. In the encapsulated interface file, the preset operations of intercepting the first static library file are executed, such as: statistical running time, success rate, forwarding calls, etc. Figure 4 As shown, the interfaces foo.o:_foo, bar.o:_bar, and baz.o:_baz of the first static library file libfoo.a, combined with the preset code, can generate corresponding encapsulation interface files hook_foo.cpp, hook_bar.cpp, and hook_baz.cpp respectively. For example, the interface foo.o:_foo corresponds to the encapsulation interface file hook_foo.cpp: hook_foo(){intercept("foo"); return foo()}, the interface bar.o:_bar corresponds to the encapsulation interface file hook_bar.cpp: hook_bar(){intercept("bar"); return bar()}, and the interface baz.o:_baz corresponds to the encapsulation interface file hook_baz.cpp: hook_baz(){intercept("baz"); return baz()}. Compile the encapsulation interface file into the second static library file lib_hook.a, including: hook_foo.o: _hook_foo, hook_bar.o: _hook_bar, hook_baz.o: _hook_baz.o: _hook_baz.

[0053] In step S330, the first static library file and the second static library file are merged to obtain a target static library file.

[0054] Among them, the interfaces of the first static library file and the second static library file can be renamed respectively using a binary editing tool such as llvm-objcopy; and the first static library file and the second static library file can be merged into a target static library file using a binary editing tool such as ar / libtool / llvm-objcopy.

[0055] In some embodiments, merging the first static library file and the second static library file to obtain a target static library file includes:

[0056] Rename the first interface name of the first target interface in the first static library file to a second interface name to obtain a first renamed static library file; wherein the second static library file calls the first static library file based on the first target interface;

[0057] renaming the first target interface in the second static library file to the second interface name; and renaming the second target interface in the second static library file to the first interface name to obtain a second renamed static library file; wherein the second target interface is used to provide the second static file externally;

[0058] The first renamed static library file and the second renamed static library file are merged to obtain the target static library file.

[0059] Among them, each first target interface to be intercepted in the first static library file is renamed, for example, by adding a real_ prefix. Correspondingly, the dependence of the second static library file on the first target interface of the first static library file is changed to dependence on the real_ function, and each intercepted second target interface of the second static library file is renamed to the interface name exposed by the first static library file. The renamed first static library file is merged with the second static library file to obtain the target static library file that completes the interception. Specifically, as Figure 4As shown, each first target interface foo.o:_foo, bar.o:_bar, baz.o:_baz to be intercepted in the first static library file libfoo.a is renamed to obtain the first renamed static library files foo.o:_real_foo, bar.o:_real_bar, baz.o:_real_baz. The dependency on the first target interface of the first static library file in the second static library file is changed to dependency on real_ functions such as _real_foo, _real_bar, _real_baz. Each intercepted second target interface hook_foo.o:_hook_foo, hook_bar.o:_hook_bar, hook_baz.o:_hook_baz in the second static library file lib_hook.a is renamed to the interface name exposed by the first static library file, that is, the second renamed static library files hook_foo.o:_foo, hook_bar.o:_bar, hook_baz.o:_baz. Merge the first renamed static library file and the second renamed static library file into the target static library file libfoo_hooked.a, including: hook_foo.o: _foo->_real_foo, hook_bar.o: _bar->_real_bar, hook_baz.o: _baz->_real_baz.

[0060] In some embodiments, method 300 further includes:

[0061] In response to the first static library file being called, the second target interface is called to execute the preset operation in the second static library file, and the first target interface is called to execute the first static library file.

[0062] Among them, when the application calls the first static library file, it will be intercepted by the second target interface corresponding to the second static library file, and the corresponding preset operation will be performed, and the first static library file will be executed by calling the first target interface connecting the first static library file and the second static library file. Although the interface provided by the target static library file to the outside is actually the second target interface in the second static library file, since the interface name of the second target interface has been renamed to the first interface name of the first target interface in the first static library file, the application or user still perceives that the interface with the first interface name is called, and will not perceive that the actual interface has changed, thereby realizing the non-perception of calling and intercepting the first static library file. It should be understood that the execution of the preset operation can be carried out simultaneously with the execution of the first static library file, or the first static library file can be executed after the preset operation is completed, which is not limited here.

[0063] In some embodiments, method 300 further includes:

[0064] In response to executing the preset operation, at least one of the following is performed:

[0065] obtaining first target data associated with an application program that calls the second target interface;

[0066] Obtaining second target data associated with the target static library file;

[0067] Execute operations on the target static library file.

[0068] An application may refer to a software program running on a computer to complete a specific task or provide a service. The first target data may refer to operational data associated with the application, such as metrics reflecting the application's performance, quality, reliability, and stability. In some embodiments, the target data may include at least one of the following: runtime, pass rate, success rate, false positive rate, and exception rate. Runtime may refer to the time it takes for an application to start and close, and can be used to measure application efficiency; a shorter runtime generally indicates higher performance. The pass rate refers to the percentage of applications that successfully pass a specific test or assessment, and can be used to measure the application's quality and reliability; a higher pass rate generally indicates good application performance. The success rate refers to the percentage of applications that successfully perform a specific task or operation, and can be used to measure the application's effectiveness and reliability; a higher success rate indicates that the application is better able to complete the task. The false positive rate refers to the percentage of samples that the application incorrectly identifies as positive out of the total number of samples, and can be used to measure the performance of a classification model; a lower false positive rate indicates a more accurate model. The exception rate refers to the percentage of exceptions that occur during the application's runtime, and can be used to measure the application's stability and reliability; a lower exception rate indicates that the application is better able to handle exceptions. The second target data may refer to the operation data associated with the target static library file, such as the data related to calling a certain interface in the target static library file. Other additional operations may also be performed on the target static library file, such as forwarding calls.

[0069] It can be seen that by encapsulating the preset operation in the target static library file, the first target data related to the application or the second target data associated with the target static library file can be detected, and the detection of the target data can be performed when the application calls the interface of the target static library file, while not affecting the execution of the static library file. It is possible to perform data detection based on the static library file, for example, effectively detect the target data such as the running time, pass rate, success rate, false alarm rate, and abnormality rate of the application, and provide comprehensive and accurate data support for improving the performance of the application and reducing the program, which is conducive to providing users with a better application experience. By encapsulating the preset operation in the target static library file, it is also possible to implement extended operations on the target static library file and increase the functions of the target static library file.

[0070] It should be noted that the method of the embodiments of the present disclosure can be performed by a single device, such as a computer or server. The method of the embodiments of the present disclosure can also be applied in a distributed scenario, where multiple devices cooperate to perform the method. In such a distributed scenario, one of the multiple devices may only perform one or more steps of the method of the embodiments of the present disclosure, and the multiple devices will interact with each other to complete the method.

[0071] It should be noted that the above description is limited to some embodiments of the present disclosure. Other embodiments are within the scope of the appended claims. In some cases, the actions or steps recited in the claims may be performed in an order different from that described in the above embodiments and still achieve the desired results. Furthermore, the processes depicted in the accompanying drawings do not necessarily require the specific order or sequential order shown to achieve the desired results. In certain embodiments, multitasking and parallel processing are also possible or may be advantageous.

[0072] Based on the same technical concept, corresponding to any of the above embodiments, the present disclosure also provides a static library file processing device, see Figure 5 , the processing device of the static library file includes:

[0073] An acquisition module is used to acquire a first static library file to be processed and a corresponding header file;

[0074] A generating module, configured to generate a second static library file including preset operations based on the header file;

[0075] A merging module is used to merge the first static library file and the second static library file to obtain a target static library file.

[0076] For the convenience of description, the above devices are described as being functionally divided into various modules. Of course, when implementing the present disclosure, the functions of each module can be implemented in the same or multiple software and / or hardware.

[0077] The device of the above embodiment is used to implement the corresponding static library file processing method in any of the above embodiments, and has the beneficial effects of the corresponding method embodiment, which will not be repeated here.

[0078] Based on the same technical concept, corresponding to any of the above-mentioned embodiments, the present disclosure also provides a non-transitory computer-readable storage medium, which stores computer instructions, and the computer instructions are used to enable the computer to execute the static library file processing method described in any of the above embodiments.

[0079] The computer-readable media of this embodiment include permanent and non-permanent, removable and non-removable media that can be used to store information by any method or technology. The information can be computer-readable instructions, data structures, program modules or other data. Examples of computer storage media include, but are not limited to, phase change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technology, read-only compact disc read-only memory (CD-ROM), digital versatile disc (DVD) or other optical storage, magnetic cassettes, magnetic tape magnetic disk storage or other magnetic storage devices or any other non-transmission media that can be used to store information that can be accessed by a computing device.

[0080] The computer instructions stored in the storage medium of the above embodiment are used to enable the computer to execute the static library file processing method described in any of the above embodiments, and have the beneficial effects of the corresponding method embodiments, which will not be repeated here.

[0081] Those skilled in the art should understand that the discussion of any of the above embodiments is merely illustrative and is not intended to imply that the scope of the present disclosure (including the claims) is limited to these examples. Within the scope of the present disclosure, the technical features in the above embodiments or different embodiments may be combined, the steps may be implemented in any order, and there are many other variations of the different aspects of the embodiments of the present disclosure as described above, which are not provided in detail for the sake of simplicity.

[0082] In addition, to simplify the description and discussion, and so as not to obscure the embodiments of the present disclosure, known power / ground connections to integrated circuit (IC) chips and other components may or may not be shown in the provided figures. In addition, devices may be shown in the form of block diagrams to avoid obscuring the embodiments of the present disclosure, and this also takes into account the fact that the details of the implementation of these block diagram devices are highly dependent on the platform on which the embodiments of the present disclosure are to be implemented (i.e., these details should be fully within the purview of those skilled in the art). Where specific details (e.g., circuits) are set forth to describe exemplary embodiments of the present disclosure, it will be apparent to those skilled in the art that the embodiments of the present disclosure may be implemented without these specific details or with variations in these specific details. Therefore, these descriptions should be considered illustrative rather than restrictive.

[0083] Although the present disclosure has been described in conjunction with specific embodiments thereof, many alternatives, modifications, and variations of these embodiments will be apparent to those skilled in the art based on the foregoing description. For example, other memory architectures (e.g., dynamic RAM (DRAM)) may use the embodiments discussed.

[0084] The embodiments of the present disclosure are intended to cover all such substitutions, modifications, and variations that fall within the broad scope of the appended claims. Therefore, any omissions, modifications, equivalent substitutions, improvements, etc. made within the spirit and principles of the embodiments of the present disclosure should be included in the scope of protection of the present disclosure.

Claims

1. A method for processing a static library file, comprising: Obtain a first static library file to be processed and a corresponding header file; Generate a second static library file including preset operations based on the header file; The first static library file and the second static library file are merged to obtain a target static library file.

2. The method according to claim 1, wherein Generating a second static library file including preset operations based on the header file, including: Generate an encapsulation interface file based on the header file and a preset code, wherein the preset code is used to implement the preset operation; The encapsulation interface file is compiled to obtain the second static library file.

3. The method according to claim 2, wherein Generate a package interface file based on the header file and the preset code, including: Analyze the header file to obtain interface information of the static library file; The encapsulated interface file is generated based on the interface information and the preset code, and the encapsulated interface file is consistent with the signature information of the interface information.

4. The method according to claim 1, wherein Merging the first static library file and the second static library file to obtain a target static library file, including: renaming a first interface name of a first target interface in the first static library file to a second interface name to obtain a first renamed static library file; wherein the second static library file calls the first static library file based on the first target interface; renaming the first target interface in the second static library file to the second interface name; and renaming the second target interface in the second static library file to the first interface name to obtain a second renamed static library file; wherein the second target interface is used to provide the second static file externally; The first renamed static library file and the second renamed static library file are merged to obtain the target static library file.

5. The method according to claim 4, comprising: In response to the first static library file being called, the second target interface is called to execute the preset operation in the second static library file, and the first target interface is called to execute the first static library file.

6. The method according to claim 5, further comprising: In response to executing the preset operation, at least one of the following is performed: obtaining first target data associated with an application program that calls the second target interface; Obtaining second target data associated with the target static library file; Execute operations on the target static library file.

7. A processing device for a static library file, comprising: An acquisition module is used to acquire a first static library file to be processed and a corresponding header file; A generating module, configured to generate a second static library file including preset operations based on the header file; A merging module is used to merge the first static library file and the second static library file to obtain a target static library file.

8. An electronic device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor implements the method according to any one of claims 1 to 6 when executing the program. 9 . A non-transitory computer-readable storage medium storing computer instructions, wherein the computer instructions are used to cause a computer to execute the method according to claim 1 .

10. A computer program product comprising computer program instructions, which, when executed on a computer, enable the computer to perform the method according to any one of claims 1 to 6.

Images