CN117632288A - Method and device for collecting and analyzing release program crash stack - Google Patents
Method and device for collecting and analyzing release program crash stack Download PDFInfo
- Publication number
- CN117632288A CN117632288A CN202311601870.XA CN202311601870A CN117632288A CN 117632288 A CN117632288 A CN 117632288A CN 202311601870 A CN202311601870 A CN 202311601870A CN 117632288 A CN117632288 A CN 117632288A
- Authority
- CN
- China
- Prior art keywords
- program
- symbol information
- debug
- script
- dynamic link
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
- 238000000034 method Methods 0.000 title claims abstract description 39
- 239000000284 extract Substances 0.000 claims abstract description 8
- 238000004590 computer program Methods 0.000 claims description 12
- 238000006243 chemical reaction Methods 0.000 claims description 3
- 230000006870 function Effects 0.000 description 18
- 238000010586 diagram Methods 0.000 description 7
- 230000008569 process Effects 0.000 description 4
- 238000012545 processing Methods 0.000 description 4
- 238000004891 communication Methods 0.000 description 3
- 230000004807 localization Effects 0.000 description 3
- 230000003287 optical effect Effects 0.000 description 3
- 230000007246 mechanism Effects 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 238000005192 partition Methods 0.000 description 2
- 230000000644 propagated effect Effects 0.000 description 2
- 238000000638 solvent extraction Methods 0.000 description 2
- 238000013459 approach Methods 0.000 description 1
- 230000009286 beneficial effect Effects 0.000 description 1
- 230000015556 catabolic process Effects 0.000 description 1
- 230000006837 decompression Effects 0.000 description 1
- 238000011161 development Methods 0.000 description 1
- 239000000835 fiber Substances 0.000 description 1
- 238000011835 investigation Methods 0.000 description 1
- 239000004973 liquid crystal related substance Substances 0.000 description 1
- 239000013307 optical fiber Substances 0.000 description 1
- 238000005457 optimization Methods 0.000 description 1
- 239000004065 semiconductor Substances 0.000 description 1
Classifications
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
- Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management
Landscapes
- Stored Programmes (AREA)
Abstract
The invention relates to a method and a device for collecting and analyzing a release program crash stack, wherein the method comprises the following steps: defining at least one dynamic link library executed prior to a main function of a target release program through a compiler, wherein the dynamic link library is used for registering or capturing various program crash signals; writing a script into the dynamic link library, wherein the script extracts debugging symbol information from the debug program through a base64 string; operating a target release program, and acquiring a crash stack of the target release program through the dynamic link library; and restoring the collapse stack into modulation symbol information through the script, and analyzing the modulation symbol information. According to the method, the device and the system, before the main function of the target release program is combined with the compiled dynamic connection library and debug, so that analysis of a crash stack is realized, and the program debugging efficiency is improved.
Description
Technical Field
The invention belongs to the technical field of computer software debugging, and particularly relates to a method and a device for collecting and analyzing a release version program crash stack.
Background
Due to the complexity of software, it cannot be guaranteed that the released version can run continuously and stably on the machine equipment without breakdown. The problem that the distributed program generally has is that in order to lighten the deployed program and realize efficient operation, symbol information and debugging information of the binary program are removed, so that when the program crashes, only hexadecimal addresses in a crashed stack and compiled function symbol information can be seen, the information is read and compared with the information, if the file name and line number information are required to be positioned, a debug program corresponding to the release program needs to be maintained, sixteen mechanism address information in the stack is analyzed by means of a compiler, the method is quite inefficient, and once the debug program is lost, the reference of debugging information is lacking when the complicated crashing problem is encountered.
Disclosure of Invention
In order to collect the crash information of the release program and improve the rejection efficiency of the crash of the release program, in a first aspect of the present invention, a method for collecting and analyzing the crash stack of the release program is provided, which comprises: defining at least one dynamic link library executed prior to a main function of a target release program through a compiler, wherein the dynamic link library is used for registering or capturing various program crash signals; writing a script into the dynamic link library, wherein the script extracts debugging symbol information from the debug program through a base64 string; operating a target release program, and acquiring a crash stack of the target release program through the dynamic link library; and restoring the collapse stack into modulation symbol information through the script, and analyzing the modulation symbol information.
In some embodiments of the present invention, the script extracting debug symbol information from the debug program via a base64 string comprises: extracting debug symbol information from the debug program by calling obj copy; compressing the debug symbol information and converting the compressed debug symbol information into a base64 word string; writing the base64 string into a script file.
Further, compiling the script file into a so dynamic link library is also included.
In some embodiments of the present invention, the restoring the collapse stack to modulation symbol information by the script and parsing the modulation symbol information comprises: restoring the collapse stack into a base64 string through the script; decoding the base64 string into binary information; decompressing the binary information to obtain the original debugging symbol information.
Further, the parsing the debug symbol information includes: and analyzing the original debugging symbol information through a code debugging tool.
In the above embodiment, the defining, by the compiler, at least one dynamic link library executed prior to the main function of the target release program includes: a dynamic link library is defined by the builder attribute of the GCC compiler, which is executed prior to the main function of the target release program.
In a second aspect of the present invention, there is provided a device for collecting and resolving a release version crash stack, comprising: the definition module is used for defining at least one dynamic link library executed prior to the main function of the target release program through the compiler, and the dynamic link library is used for registering or capturing various program crash signals; the writing module is used for writing a script into the dynamic link library at least, and the script extracts debugging symbol information from the debug program through a base64 string; the operation module is used for operating the target release program and acquiring a crash stack of the target release program through the dynamic link library; and the analysis module is used for restoring the collapse stack into modulation symbol information through the script and analyzing the modulation symbol information.
Further, the writing module includes: a calling unit for extracting debug symbol information from the debug program by calling obj copy; the conversion unit is used for compressing the debug symbol information and converting the debug symbol information into a base64 word string; and the writing unit is used for writing the base64 word string into a script file.
In a third aspect of the present invention, there is provided an electronic apparatus comprising: one or more processors; and the storage device is used for storing one or more programs, and when the one or more programs are executed by the one or more processors, the one or more processors are enabled to realize the method for collecting and analyzing the release program crash stack provided by the first aspect of the invention.
In a fourth aspect of the present invention, a computer readable medium is provided, on which a computer program is stored, wherein the computer program, when executed by a processor, implements the method for collecting and resolving a release program crash stack provided in the first aspect of the present invention.
The beneficial effects of the invention are as follows:
the invention relates to a method and a device for collecting and analyzing a release program crash stack, wherein the method comprises the following steps: defining at least one dynamic link library executed prior to a main function of a target release program through a compiler, wherein the dynamic link library is used for registering or capturing various program crash signals; writing a script into the dynamic link library, wherein the script extracts debugging symbol information from the debug program through a base64 string; operating a target release program, and acquiring a crash stack of the target release program through the dynamic link library; and restoring the collapse stack into modulation symbol information through the script, and analyzing the modulation symbol information.
Therefore, under the condition of not depending on the debugging version program, the method can restore the crash stack information of the issuing version program when running on the equipment directly based on the crash file captured by the issuing version program, and can present file names, line numbers, class names and method names. Compared with the prior art that a debugging version program is needed for acquiring detailed crash stack information, or various printing is needed to trace the problem investigation mode under the condition that the relatively-bulky information with debugging symbols is not allowed to be used, the problem localization efficiency is provided, the problem localization efficiency is improved, the problem information processed by the release version program can be generated when the crash fault occurs on site, the processed crash information can be stored on equipment, the crash data can be reported through a network background, and the problem localization links and the serious dependence on the environment are reduced.
Drawings
FIG. 1 is a basic flow diagram of a method for collecting and resolving a release version crash stack according to some embodiments of the invention;
FIG. 2 is a flowchart illustrating a method for collecting and resolving a release version crash stack according to some embodiments of the present invention;
FIG. 3 is a schematic diagram illustrating an apparatus for collecting and resolving a release version crash stack according to some embodiments of the present invention;
fig. 4 is a schematic structural diagram of an electronic device according to some embodiments of the present invention.
Detailed Description
The principles and features of the present invention are described below with reference to the drawings, the examples are illustrated for the purpose of illustrating the invention and are not to be construed as limiting the scope of the invention.
Referring to fig. 1 and 2, in a first aspect of the present invention, a method for collecting and resolving a release program crash stack is provided, including: s100, defining at least one dynamic link library executed before a main function of a target release program through a compiler, wherein the dynamic link library is used for registering or capturing various program crash signals; s200, writing a script into the dynamic link library at least, wherein the script extracts debugging symbol information from a debug program through a base64 string; s300, running a target release program, and acquiring a crash stack of the target release program through the dynamic link library; s400, restoring the collapse stack into modulation symbol information through the script, and analyzing the modulation symbol information.
It will be appreciated that during the software development process, there should be two versions (Debug version and Release version) for each program, the Debug version needs to add many additional debugging means for debugging and problem discovery, and the Release version needs to perform some optimization on the program for performance and user experience, for example: debug means of Debug phase are removed. The debugging symbol information or symbol information mentioned in the present invention mainly refers to hexadecimal addresses in a crash stack and compiled function symbol information.
The division into Debug/Release versions is not a feature of the C/C++ language; the two phases are needed to distinguish regardless of the language used to write the program, but the other languages (e.g., java, etc.) have relatively low performance requirements and different compiling and running mechanisms from the C/c++ language and have better dynamics (the debugging means such as journals can be dynamically set at runtime) so the partitioning requirements of Debug/Release versions are not as obvious as C/c++.
Partitioning of Debug/Release versions is not a specific approach, but a strategy that can be customized; compiler options and use of IDE (Integrated development Environment) can generate versions with Debug information, that is, language-level Debug/Release version partitions, also requiring a service-level Debug/Release version partition, such as: different Log outputs at Debug/Release stage.
In step S100 of some embodiments of the present invention, the defining, by the compiler, at least one dynamic link library executed prior to the main function of the target release program includes: a dynamic link library is defined by the builder attribute of the GCC compiler, which is executed prior to the main function of the target release program.
Specifically, a method which can be automatically executed before a main function is compiled to a so (dynamic link library) by using a structor attribute modification definition of gcc, various crash signals are registered in the method for capturing, and thus, when a program loads the so, the registration of the crash signal capturing is automatically executed; when the program is running, the so of step 1 is automatically preloaded before the execution process using the system environment variable LD_PRELOAD. It will be appreciated that the dynamically linked libraries in the above embodiments are implemented with the so files in Linux, and do not affect the implementation of dynamically linked libraries other than the so files (e.g., dll files) by one or more compilers by those skilled in the art.
In step S200 of some embodiments of the present invention, the extracting debug symbol information from the debug program by the base64 string by the script includes:
s201, extracting debugging symbol information from a debug program by calling obj copy;
s202, compressing the debugging symbol information and converting the compressed debugging symbol information into a base64 string; writing the base64 string into a script file.
Specifically, a script tool is written as a compiling tool of the target program, which automatically calls obj copy to extract symbol information from the debug program, compresses and then converts the string of base64 to generate string constants in the code, compiles the string constants into the so of step 1 (the so contains a method for acquiring symbol information), and then changes the debug program strip into a release version. When the tool is manufactured, the fact that the tool can take the base64 word string corresponding to the symbol information through the related method in the so generated in the step 1 by the executable program and reversely convert the base64 word string into the original symbol information needs to be considered; alternatively, the above-described obj copy is merely used to extract symbol information from the debug program, and does not affect the implementation of the copy tool by other debug by those skilled in the art.
It should be noted that, the program strip with debug information is not equal to the Release version, the program compiled by the compiler with the addition of-g and other compiling options will carry debug information, the strip program will remove the debug information and symbol table carried by the program, although the file sizes of binary program strips generated in two ways are the same, the Release version of the language layer is generated, and the debugging means of the business layer still exist, for example: assertions, self-imposed debugging means, and the existence of these means (assertions) is very dangerous.
In step S300 of some embodiments of the present invention, a target release program is run, and a crash stack of the target release program is obtained through the dynamic link library.
Specifically, after the release program is run on the machine, since the so dynamic link library in step S100 is automatically loaded through ld_reload, crash information is automatically captured and generated to a corresponding file after the program crashes, and the crash stack (16-system address, not directly readable) of the release program is inside.
In step S400 of some embodiments of the present invention, the restoring the collapse stack into modulation symbol information through the script, and resolving the modulation symbol information includes:
s401, restoring the collapse stack into a base64 string through the script;
s402, decoding the base64 word string into binary information;
s403, decompressing the binary information to obtain the original debugging symbol information.
Specifically, after a crash stack file generated by a release program is acquired, a tool (script file) manufactured in the step S100 is used for calling a method for acquiring a base64 string in a matched so, then the base64 is decoded into binary information, and decompression is called and restored into original symbol information;
further, the parsing the debug symbol information includes: and analyzing the original debugging symbol information through a code debugging tool.
Specifically, calling an addr2line matched with a compiler resolves a 16-system address in a crash stack, and calling a c++ filt of a system can resolve a function symbol in the crash stack to restore the function symbol into a class name and a method name.
Example 2
Referring to fig. 3, in a second aspect of the present invention, there is provided a device 1 for collecting and resolving a release program crash stack, comprising: the definition module 11 is configured to define, by using a compiler, at least one dynamic link library executed prior to a main function of a target release program, where the dynamic link library is configured to register or capture various program crash signals; a writing module 12, configured to write at least one script into the dynamic link library, where the script extracts debug symbol information from the debug program through a base64 string; the operation module 13 is used for operating the target release program and acquiring a crash stack of the target release program through the dynamic link library; and the parsing module 14 is configured to restore the collapse stack to modulation symbol information through the script, and parse the modulation symbol information.
Further, the writing module 12 includes: a calling unit for extracting debug symbol information from the debug program by calling obj copy; the conversion unit is used for compressing the debug symbol information and converting the debug symbol information into a base64 word string; and the writing unit is used for writing the base64 word string into a script file.
Example 3
Referring to fig. 4, a third aspect of the present invention provides an electronic device, including: one or more processors; and storage means for storing one or more programs which, when executed by the one or more processors, cause the one or more processors to implement the method of the present invention in the first aspect.
The electronic device 500 may include a processing means (e.g., a central processing unit, a graphics processor, etc.) 501 that may perform various appropriate actions and processes in accordance with programs stored in a Read Only Memory (ROM) 502 or loaded from a storage 508 into a Random Access Memory (RAM) 503. In the RAM 503, various programs and data required for the operation of the electronic apparatus 500 are also stored. The processing device 501, the ROM 502, and the RAM 503 are connected to each other via a bus 504. An input/output (I/O) interface 505 is also connected to bus 504.
The following devices may be connected to the I/O interface 505 in general: input devices 506 including, for example, a touch screen, touchpad, keyboard, mouse, camera, microphone, accelerometer, gyroscope, etc.; an output device 507 including, for example, a Liquid Crystal Display (LCD), a speaker, a vibrator, and the like; storage 508 including, for example, a hard disk; and communication means 509. The communication means 509 may allow the electronic device 500 to communicate with other devices wirelessly or by wire to exchange data. While fig. 4 shows an electronic device 500 having various means, it is to be understood that not all of the illustrated means are required to be implemented or provided. More or fewer devices may be implemented or provided instead. Each block shown in fig. 4 may represent one device or a plurality of devices as needed.
In particular, according to embodiments of the present disclosure, the processes described above with reference to flowcharts may be implemented as computer software programs. For example, embodiments of the present disclosure include a computer program product comprising a computer program embodied on a computer readable medium, the computer program comprising program code for performing the method shown in the flowcharts. In such an embodiment, the computer program may be downloaded and installed from a network via the communication means 509, or from the storage means 508, or from the ROM 502. The above-described functions defined in the methods of the embodiments of the present disclosure are performed when the computer program is executed by the processing device 501. It should be noted that the computer readable medium described in the embodiments of the present disclosure may be a computer readable signal medium or a computer readable storage medium or any combination of the two. The computer readable storage medium can be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or a combination of any of the foregoing. More specific examples of the computer-readable storage medium may include, but are not limited to: an electrical connection having one or more wires, a portable computer diskette, a hard disk, a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing. In an embodiment of the present disclosure, a computer readable storage medium may be any tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device. Whereas in embodiments of the present disclosure, the computer-readable signal medium may comprise a data signal propagated in baseband or as part of a carrier wave, with computer-readable program code embodied therein. Such a propagated data signal may take any of a variety of forms, including, but not limited to, electro-magnetic, optical, or any suitable combination of the foregoing. A computer readable signal medium may also be any computer readable medium that is not a computer readable storage medium and that can communicate, propagate, or transport a program for use by or in connection with an instruction execution system, apparatus, or device. Program code embodied on a computer readable medium may be transmitted using any appropriate medium, including but not limited to: electrical wires, fiber optic cables, RF (radio frequency), and the like, or any suitable combination of the foregoing.
The computer readable medium may be contained in the electronic device; or may exist alone without being incorporated into the electronic device. The computer readable medium carries one or more computer programs which, when executed by the electronic device, cause the electronic device to:
computer program code for carrying out operations of embodiments of the present disclosure may be written in one or more programming languages, including an object oriented programming language such as Java, smalltalk, C ++, python and conventional procedural programming languages, such as the "C" programming language or similar programming languages. The program code may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server. In the case of a remote computer, the remote computer may be connected to the user's computer through any kind of network, including a Local Area Network (LAN) or a Wide Area Network (WAN), or may be connected to an external computer (for example, through the Internet using an Internet service provider).
The flowcharts and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present disclosure. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of code, which comprises one or more executable instructions for implementing the specified logical function(s). It should also be noted that, in some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will be noted that each block of the block diagrams and/or flowchart illustration, and combinations of blocks in the block diagrams and/or flowchart illustration, can be implemented by special purpose hardware-based systems which perform the specified functions or acts, or combinations of special purpose hardware and computer instructions.
The foregoing description of the preferred embodiments of the invention is not intended to limit the invention to the precise form disclosed, and any such modifications, equivalents, and alternatives falling within the spirit and scope of the invention are intended to be included within the scope of the invention.
Claims (10)
1. A method for collecting and resolving a release program crash stack, comprising:
defining at least one dynamic link library executed prior to a main function of a target release program through a compiler, wherein the dynamic link library is used for registering or capturing various program crash signals;
writing a script into the dynamic link library, wherein the script extracts debugging symbol information from the debug program through a base64 string;
operating a target release program, and acquiring a crash stack of the target release program through the dynamic link library;
and restoring the collapse stack into modulation symbol information through the script, and analyzing the modulation symbol information.
2. The method of claim 1, wherein the script extracting debug symbol information from the debug program via a base64 string comprises:
extracting debug symbol information from the debug program by calling obj copy;
compressing the debug symbol information and converting the compressed debug symbol information into a base64 word string;
writing the base64 string into a script file.
3. The method of collecting and parsing a release program crash stack as recited in claim 2, further comprising compiling the script file into a so dynamic link library.
4. The method of claim 1, wherein the restoring the crash stack to modulation symbol information by the script and parsing the modulation symbol information comprises:
restoring the collapse stack into a base64 string through the script;
decoding the base64 string into binary information;
decompressing the binary information to obtain the original debugging symbol information.
5. The method of collecting and parsing a release program crash stack according to claim 4, wherein the parsing the debug symbol information comprises: and analyzing the original debugging symbol information through a code debugging tool.
6. The method of any one of claims 1 to 5, wherein defining, by the compiler, at least one dynamic link library to be executed prior to a main function of the target release program comprises:
a dynamic link library is defined by the builder attribute of the GCC compiler, which is executed prior to the main function of the target release program.
7. A device for collecting and resolving a release program crash stack, comprising:
the definition module is used for defining at least one dynamic link library executed prior to the main function of the target release program through the compiler, and the dynamic link library is used for registering or capturing various program crash signals;
the writing module is used for writing a script into the dynamic link library at least, and the script extracts debugging symbol information from the debug program through a base64 string;
the operation module is used for operating the target release program and acquiring a crash stack of the target release program through the dynamic link library;
and the analysis module is used for restoring the collapse stack into modulation symbol information through the script and analyzing the modulation symbol information.
8. The apparatus for collecting and resolving a release program crash stack as recited in claim 7, wherein the writing module comprises:
a calling unit for extracting debug symbol information from the debug program by calling obj copy;
the conversion unit is used for compressing the debug symbol information and converting the debug symbol information into a base64 word string;
and the writing unit is used for writing the base64 word string into a script file.
9. An electronic device, comprising: one or more processors; storage means for storing one or more programs which, when executed by the one or more processors, cause the one or more processors to implement the collect and resolve release program crash stack method as claimed in any one of claims 1 to 6.
10. A computer readable medium having stored thereon a computer program, wherein the computer program when executed by a processor implements the collecting and resolving release program crash stack method according to any of claims 1 to 6.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202311601870.XA CN117632288A (en) | 2023-11-24 | 2023-11-24 | Method and device for collecting and analyzing release program crash stack |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202311601870.XA CN117632288A (en) | 2023-11-24 | 2023-11-24 | Method and device for collecting and analyzing release program crash stack |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN117632288A true CN117632288A (en) | 2024-03-01 |
Family
ID=90035139
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202311601870.XA Pending CN117632288A (en) | 2023-11-24 | 2023-11-24 | Method and device for collecting and analyzing release program crash stack |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN117632288A (en) |
-
2023
- 2023-11-24 CN CN202311601870.XA patent/CN117632288A/en active Pending
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US10891120B2 (en) | Performing a compiler optimization pass as a transaction | |
| CN110032392B (en) | Service management method and device, storage medium and electronic equipment | |
| CN111240684B (en) | Cutting method and device of JS codes, medium and electronic equipment | |
| CN111611145B (en) | Breakdown information collection method and device, storage medium and electronic equipment | |
| CN111367516B (en) | Application interface generation method and device and electronic equipment | |
| CN109947431B (en) | Code generation method, device, equipment and storage medium | |
| CN111427569A (en) | Installation-free program adapting method and device, electronic equipment and storage medium | |
| CN111782523A (en) | Cloud service deployment test method and device, electronic equipment and storage medium | |
| US10216502B2 (en) | System module deployment optimization | |
| CN110659210A (en) | Information acquisition method and device, electronic equipment and storage medium | |
| CN117632288A (en) | Method and device for collecting and analyzing release program crash stack | |
| CN114840195B (en) | Privatization method for iOS SDK static library | |
| US9069643B1 (en) | Creating a prerequisite checklist corresponding to a software application | |
| US8806465B2 (en) | Refactor exception class hierarchy for reduced footprint and faster application start | |
| CN113778451B (en) | File loading method, file loading device, computer system and computer readable storage medium | |
| CN114968260A (en) | Hybrid pre-compiling method and device, electronic equipment and storage medium | |
| US11797277B2 (en) | Neural network model conversion method server, and storage medium | |
| CN110297639B (en) | Method and apparatus for detecting code | |
| CN112394920A (en) | Application software development method, platform and electronic equipment | |
| CN114253615B (en) | Method and device for setting bootstrap program, electronic equipment and storage medium | |
| CN112929675B (en) | Image resource compression method and device and electronic equipment | |
| CN114780107B (en) | Grammar analysis method and device of rule running file and decision engine | |
| CN113342347A (en) | Information processing method, device, computing equipment and medium | |
| CN117667588A (en) | Abnormality determination method, abnormality determination device, abnormality determination equipment and storage medium | |
| CN116483316A (en) | Development kit compatible processing method, device, equipment, storage medium and product |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |