CN108984328B - Stack backtracking method and device - Google Patents
Stack backtracking method and device Download PDFInfo
- Publication number
- CN108984328B CN108984328B CN201710398429.4A CN201710398429A CN108984328B CN 108984328 B CN108984328 B CN 108984328B CN 201710398429 A CN201710398429 A CN 201710398429A CN 108984328 B CN108984328 B CN 108984328B
- Authority
- CN
- China
- Prior art keywords
- stack
- frame structure
- current
- stack frame
- function
- 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.)
- Active
Links
- 238000000034 method Methods 0.000 title claims abstract description 43
- 230000006870 function Effects 0.000 claims abstract description 117
- 238000004458 analytical method Methods 0.000 claims description 5
- 238000010586 diagram Methods 0.000 description 7
- 230000003287 optical effect Effects 0.000 description 2
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/07—Responding to the occurrence of a fault, e.g. fault tolerance
- G06F11/0703—Error or fault processing not based on redundancy, i.e. by taking additional measures to deal with the error or fault not making use of redundancy in operation, in hardware, or in data representation
- G06F11/0706—Error or fault processing not based on redundancy, i.e. by taking additional measures to deal with the error or fault not making use of redundancy in operation, in hardware, or in data representation the processing taking place on a specific hardware platform or in a specific software environment
- G06F11/0736—Error or fault processing not based on redundancy, i.e. by taking additional measures to deal with the error or fault not making use of redundancy in operation, in hardware, or in data representation the processing taking place on a specific hardware platform or in a specific software environment in functional embedded systems, i.e. in a data processing system designed as a combination of hardware and software dedicated to performing a certain function
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/362—Software debugging
- G06F11/366—Software debugging using diagnostics
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Quality & Reliability (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Computer Hardware Design (AREA)
- Debugging And Monitoring (AREA)
- Devices For Executing Special Programs (AREA)
Abstract
The document discloses a method and a device for stack backtracking, which comprises the following steps: acquiring a memory value at the current FP-4 position; determining the stack frame structure type used by the current function according to the memory value; acquiring a return address and a parent function frame pointer FP according to the stack frame structure type; and the current FP-4 is the memory address of the position where the value of the current function FP moves 4 bytes in the direction of the low address. According to the method and the device, the stack frame structure of the ARM system program can be automatically identified and processed according to different structures, so that the stack frame backtracking method can correctly backtrack stacks of different stack frame structure programs, and the correctness and the practicability of the stack frame backtracking method are greatly enhanced.
Description
Technical Field
The invention relates to the field of embedded systems, in particular to a stack backtracking method and device.
Background
At present, three methods of stack backtracking exist, namely a stack frame backtracking method, an instruction analysis method and an unwender backtracking method. The stack Frame backtracking method directly reads a return address and a Frame Pointer (FP, Frame Pointer) of a parent function from a fixed position in a current function stack, and a schematic diagram of a stack Frame backtracking structure is given in fig. 1. The algorithm is closely related to the frame structure of the function stack, and the Advanced reduced instruction set Machine (ARM) architecture Application Binary Interface (ABI) specifies three typical frame structures of the stack.
In the related art, stack frame backtracking algorithms for the ARM system are all designed according to one stack frame structure, and cannot process other stack frame structures, so that backtracking fails completely once functions adopting other stack frame structures are encountered during backtracking. With the development of compilers, other types of stack frame structures are used more and more, so that the stack frame backtracking algorithm for the ARM system in the related art cannot meet the requirements more and more, and an algorithm capable of automatically identifying three different stack frame structures and performing corresponding processing is urgently needed.
Disclosure of Invention
In order to solve the above technical problems, embodiments of the present invention provide a method and an apparatus for stack backtracking, which can correctly backtrack stacks of different stack frame structure programs.
In order to achieve the purpose of the invention, the invention provides a
A method of stack backtracking, comprising:
acquiring a memory value at the current FP-4 position;
determining the stack frame structure type used by the current function according to the memory value;
acquiring a return address and a parent function frame pointer FP according to the stack frame structure type;
and the current FP-4 is the memory address of the position where the value of the current function FP moves 4 bytes in the direction of the low address.
Wherein, the determining the stack frame structure type used by the current function according to the memory value at the current FP-4 position includes: when the memory value is in the range of the program code segment, determining that the current function uses a first stack frame structure; when the memory value is in the range of the current thread stack, determining that the current function uses a second stack frame structure; and when the memory value is neither in the range of the program code segment nor in the range of the current thread stack, determining that the current function uses a third stack frame structure.
Acquiring a return address and a parent function frame pointer FP according to the stack frame structure type, wherein the method comprises the following steps: under the condition that the stack frame structure type is a first stack frame structure, reading a return address from a memory corresponding to FP-4, and reading an FP of a parent function from a memory corresponding to FP-12; for the second stack frame structure, reading a return address from a memory corresponding to the FP, and reading the FP of the parent function from a memory corresponding to the FP-4; for the third stack frame structure, the current function stack SIZE is obtained, FP of the parent function is read from FP + SIZE, and the return address is read from FP + SIZE + 4.
Wherein, the obtaining the stack SIZE of the function includes: performing instruction analysis from the current PC to the low address direction, and searching for an instruction of an extension stack; under the condition that the instruction of the extension stack is found, the SIZE SIZE of the function stack is an immediate number in the instruction; if no instruction to expand the stack is found, then the stack SIZE SIZE is 0.
An apparatus for stack backtracking, comprising:
the acquisition module is used for acquiring a memory value at the current FP-4 position;
the determining module is used for determining the stack frame structure type used by the current function according to the memory value at the current FP-4 position;
the return module is used for acquiring a return address and a parent function frame pointer FP according to the stack frame structure type;
and the current FP-4 is the memory address of the position where the value of the current function FP moves 4 bytes in the direction of the low address.
Wherein the determining module is specifically configured to: when the memory value is in the range of the program code segment, determining that the current function uses a first stack frame structure; when the memory value is in the range of the current thread stack, determining that the current function uses a second stack frame structure; and when the memory value is neither in the range of the program code segment nor in the range of the current thread stack, determining that the current function uses a third stack frame structure.
Wherein, the return module is specifically configured to: for the first stack frame structure, reading a return address from a memory corresponding to FP-4, and reading the FP of the parent function from a memory corresponding to FP-12; for the second stack frame structure, reading a return address from a memory corresponding to the FP, and reading the FP of the parent function from a memory corresponding to the FP-4; for the third stack frame structure, the current function stack SIZE SIZE is calculated, the FP of the parent function is read from FP + SIZE, and the return address is read from FP + SIZE + 4.
An apparatus for stack backtracking, comprising:
a memory storing a stack trace-back program;
a processor configured to execute the stack trace back procedure to perform the following operations: acquiring a memory value at the current FP-4 position; determining the stack frame structure type used by the current function according to the memory value at the current FP-4 position; acquiring a return address and a parent function frame pointer FP according to the stack frame structure type; and the current FP-4 is the memory address of the position where the value of the current function FP moves 4 bytes in the direction of the low address.
A computer readable storage medium, on which a stack trace-back program is stored, which when executed by a processor implements the steps of the above-mentioned stack trace-back method.
In the embodiment of the invention, the stack frame structure of the ARM system program can be automatically identified and processed according to different structures, so that the stack frame backtracking method can correctly backtrack the stacks of different stack frame structure programs, and the correctness and the practicability of the stack frame backtracking method are greatly enhanced.
Additional features and advantages of the invention will be set forth in the description which follows, and in part will be obvious from the description, or may be learned by practice of the invention. The objectives and other advantages of the invention will be realized and attained by the structure particularly pointed out in the written description and claims hereof as well as the appended drawings.
Drawings
The accompanying drawings are included to provide a further understanding of the invention and are incorporated in and constitute a part of this specification, illustrate embodiments of the invention and together with the example serve to explain the principles of the invention and not to limit the invention.
FIG. 1 is a diagram illustrating a stack frame trace-back in the related art;
FIG. 2 is a diagram of a first stack frame structure of an ARM;
FIG. 3 is a diagram illustrating an ARM second stack frame structure;
FIG. 4 is a diagram illustrating a third stack frame structure of an ARM;
FIG. 5 is a flowchart illustrating a method for stack backtracking according to an embodiment of the present invention;
FIG. 6 is a flowchart illustrating an embodiment of stack backtracking according to the present invention;
fig. 7 is a schematic structural diagram of a stack backtracking apparatus according to an embodiment of the present invention.
Detailed Description
In order to make the objects, technical solutions and advantages of the present invention more apparent, embodiments of the present invention will be described in detail below with reference to the accompanying drawings. It should be noted that the embodiments and features of the embodiments in the present application may be arbitrarily combined with each other without conflict.
The steps illustrated in the flow charts of the figures may be performed in a computer system such as a set of computer-executable instructions. Also, while a logical order is shown in the flow diagrams, in some cases, the steps shown or described may be performed in an order different than here.
The ARM architecture ABI specifies three typical stack frame structures, respectively: the frame structure comprises a first stack frame structure of the ARM, a second stack frame structure of the ARM, and a third stack frame structure of the ARM, wherein the first stack frame structure of the ARM is shown in fig. 2, the second stack frame structure of the ARM is shown in fig. 3, and the third stack frame structure of the ARM is shown in fig. 4. Here, in fig. 2, 3, and 4, FP denotes a frame pointer register; PC denotes a program counter; LR denotes a return address register; SP denotes a stack register.
As can be seen from FIGS. 2, 3, and 4, for the first stack frame structure, a return address is stored at FP-4, and an FP of a parent function is stored at FP-12; for the second stack frame structure, the return address is stored at FP, and the FP of the parent function is stored at FP-4; for the third stack frame structure, other stack contents of the function are separated between the FP and the storage position of the parent function FP, local variables, real parameters and the like are possible, for different functions, the contents are different, so that the SIZEs of the contents are not fixed, the storage position of the parent function FP cannot be directly located through the FP, the stack SIZE SIZE of the function needs to be calculated, and then the FP and the return address of the parent function can be acquired from the FP + SIZE and the FP + SIZE +4 respectively.
In the prior art, stack frame backtracking algorithms for ARM systems are all designed according to a first stack frame structure of the above three stack frame structures, and cannot process two stack frame structures, namely a second stack frame structure and a third stack frame structure, so that backtracking fails completely once a function adopting the second stack frame structure and the third stack frame structure is encountered during backtracking. With the development of compilers, the second stack frame structure and the third stack frame structure are used more and more, so that the stack frame backtracking algorithm for the ARM system in the related art can not meet the requirements more and more, and an algorithm capable of automatically identifying three different stack frame structures and performing corresponding processing is urgently needed.
The application provides a stack backtracking scheme aiming at the problems in the prior art, can realize the self-adaptive stack backtracking of various stack frame formats of the ARM architecture, can automatically identify which stack frame format is adopted by the ARM architecture program, and adopts a corresponding algorithm to perform backtracking.
As shown in fig. 5, the present application provides a method for stack backtracking, which includes:
According to the method, the memory value of the current FP-4 position is obtained, then the stack frame structure of which the function is used is automatically judged, and then the corresponding backtracking algorithm is adopted according to the characteristics of different stack frame structures, so that the stack frame structure of the ARM system program can be automatically identified and processed according to different structures, the stacks of different stack frame structure programs can be correctly backtracked by the stack frame backtracking method, and the correctness and the practicability of the stack frame backtracking method are greatly enhanced.
It should be noted that, in this document, FP-4 refers to a memory address where the value of FP moves 4 bytes in the low address direction, and FP-12 refers to a memory address where the value of FP moves 12 bytes in the low address direction. Correspondingly, the current FP-4 refers to the memory address where the value of the current function FP moves 4 bytes in the low address direction.
As can be seen from fig. 2, 3, 4, for the first stack frame structure, it is the return address that is held at FP-4, and the return address is within the program code section; for the second stack frame structure, the FP of the parent function is stored at the FP-4, and the FP is a stack frame register and is in the range of the thread stack; for the third stack frame structure, held at FP-4 is some temporary data for the function, neither within the code segment nor within the thread stack. Therefore, which stack frame structure the function uses can be determined according to the range of memory values at the FP-4 position. After the stack frame structure of the function is judged, the return address and the parent function FP can be obtained by adopting a corresponding algorithm according to the characteristics of different stack frame structures.
Based on the above, in this application, the determining the stack frame structure type used by the current function according to the memory value at the current FP-4 position may include: when the memory value is in the range of the program code segment, determining that the current function uses a first stack frame structure; when the memory value is in the range of the current thread stack, determining that the current function uses a second stack frame structure; and when the memory value is neither in the range of the program code segment nor in the range of the current thread stack, determining that the current function uses a third stack frame structure.
In this application, obtaining a return address and a parent function frame pointer FP by using a backtracking algorithm matched with the stack frame structure type may include: for the first stack frame structure, reading a return address from a memory corresponding to FP-4, and reading the FP of the parent function from a memory corresponding to FP-12; for the second stack frame structure, reading a return address from a memory corresponding to the FP, and reading the FP of the parent function from a memory corresponding to the FP-4; for the third stack frame structure, the current function stack SIZE SIZE is calculated, the FP of the parent function is read from FP + SIZE, and the return address is read from FP + SIZE + 4.
Here, the manner of calculating the present function stack SIZE may be various. For example, the following may be employed: performing instruction analysis from the current PC to the low address direction, and searching for an instruction of an extension stack; if the instruction of the extension stack is found, the immediate number in the instruction is the SIZE SIZE of the function stack; if no instruction to expand the stack is found, then the stack SIZE SIZE is 0.
For example, the specific process of stack backtracking in the present application may adopt the flow shown in fig. 6. In practical applications, the process of stack backtracking in the present application may also adopt other processes, which is not limited herein.
As shown in fig. 6, the specific process of stack backtracking may include:
If the obtained memory value is in the program code segment range, it indicates that the stored address is the return address, and the current trace back function uses the first stack frame structure shown in fig. 2, then the process goes to step 603;
if the acquired memory value is in the current thread stack range, it indicates that the stored memory value is a parent function FP, and the current backtracking function uses the second stack frame structure shown in fig. 3, then the process jumps to step 604;
if the obtained memory value is neither within the program code segment nor within the current thread stack, then the jump to step uses the third stack frame structure shown in fig. 4, and then the jump to step 605 is performed.
Here, since the other stack contents of the function (i.e., the stack SIZE of the function) are separated from the storage location of the FP and the parent FP, the stack SIZE of the function is calculated first.
Here, a specific way of calculating the present function stack SIZE may be: performing instruction analysis from the current PC to the low address direction, and searching an instruction of an extension stack, wherein the instruction format is as follows:
sub sp,#imm；
wherein, the immediate imm is the stack SIZE SIZE of the function. If no instruction to extend the stack is found, indicating that the function has no extension stack (function has no parameters and no local variables), then the stack SIZE SIZE is 0.
Correspondingly, the present application further provides a device for stack backtracking, as shown in fig. 7, including:
an obtaining module 71, configured to obtain a memory value at a current FP-4 position;
a determining module 72, configured to determine, according to a memory value at the current FP-4 position, a stack frame structure type used by the current function;
and the return module 73 is configured to obtain a return address and a parent function FP according to the stack frame structure type.
The determining module 72 is specifically configured to: when the memory value is in the range of the program code segment, determining that the current function uses a first stack frame structure; when the memory value is in the range of the current thread stack, determining that the current function uses a second stack frame structure; and when the memory value is neither in the range of the program code segment nor in the range of the current thread stack, determining that the current function uses a third stack frame structure.
The return module 73 is specifically configured to: for the first stack frame structure, reading a return address from a memory corresponding to FP-4, and reading the FP of the parent function from a memory corresponding to FP-12; for the second stack frame structure, reading a return address from a memory corresponding to the FP, and reading the FP of the parent function from a memory corresponding to the FP-4; for the third stack frame structure, the current function stack SIZE SIZE is calculated, the FP of the parent function is read from FP + SIZE, and the return address is read from FP + SIZE + 4.
In the present application, the stack trace apparatus can implement all the details of the stack trace method (including the flows shown in fig. 5 and fig. 6). In practical applications, in the above apparatus for stack backtracking, the obtaining module 71, the determining module 72, and the returning module 73 may be software, hardware, or a combination of both.
Correspondingly, this application still provides another kind of device that stacks was traced back, includes:
a memory storing a stack trace-back program;
a processor configured to execute the stack trace back procedure to perform the following operations: acquiring a memory value at the current FP-4 position; determining the stack frame structure type used by the current function according to the memory value at the current FP-4 position; and acquiring a return address and a parent function FP according to the stack frame structure type.
In the present application, the stack trace apparatus can implement all the details of the stack trace method (including the flows shown in fig. 5 and fig. 6).
In addition, an embodiment of the present application further provides a computer-readable storage medium, where a stack trace-back program is stored on the computer-readable storage medium, and the stack trace-back program implements the steps of the stack trace-back method when executed by a processor.
Alternatively, the storage medium may include, but is not limited to: a U-disk, a Read-Only Memory (ROM), a Random Access Memory (RAM), a removable hard disk, a magnetic or optical disk, and other various media capable of storing program codes.
Optionally, the processor performs the method steps of the above embodiments according to program code stored in the storage medium.
It will be understood by those skilled in the art that all or part of the steps of the above methods may be implemented by a program instructing associated hardware (e.g., a processor) to perform the steps, and the program may be stored in a computer readable storage medium, such as a read only memory, a magnetic or optical disk, and the like. Alternatively, all or part of the steps of the above embodiments may be implemented using one or more integrated circuits. Accordingly, the modules/units in the above embodiments may be implemented in hardware, for example, by an integrated circuit, or may be implemented in software, for example, by a processor executing programs/instructions stored in a memory to implement the corresponding functions. The present application is not limited to any specific form of hardware or software combination.
The foregoing shows and describes the general principles and features of the present application, together with the advantages thereof. The present application is not limited to the above-described embodiments, which are described in the specification and drawings only to illustrate the principles of the application, but also to provide various changes and modifications within the spirit and scope of the application, which are within the scope of the claimed application.
Claims (9)
1. A method of stack backtracking, comprising:
acquiring a memory value at the current FP-4 position;
determining a stack frame structure type used by the current function according to the memory value, wherein the stack frame structure type comprises: the frame structure comprises a first stack frame structure of ARM, a second stack frame structure of ARM and a third stack frame structure of ARM;
acquiring a return address and a parent function frame pointer FP according to the stack frame structure type;
and the current FP-4 is the memory address of the position where the value of the current function FP moves 4 bytes in the direction of the low address.
2. The method of claim 1, wherein determining the type of stack frame structure used by the current function from the memory value comprises:
when the memory value is in the range of the program code segment, determining that the current function uses a first stack frame structure;
when the memory value is in the range of the current thread stack, determining that the current function uses a second stack frame structure;
and when the memory value is neither in the range of the program code segment nor in the range of the current thread stack, determining that the current function uses a third stack frame structure.
3. The method of claim 1 or 2, wherein obtaining a return address and a parent function frame pointer FP according to the stack frame structure type comprises:
under the condition that the stack frame structure type is a first stack frame structure, reading a return address from a memory corresponding to FP-4, and reading an FP of a parent function from a memory corresponding to FP-12;
for the second stack frame structure, reading a return address from a memory corresponding to the FP, and reading the FP of the parent function from a memory corresponding to the FP-4;
for the third stack frame structure, the current function stack SIZE is obtained, FP of the parent function is read from FP + SIZE, and the return address is read from FP + SIZE + 4.
4. The method of claim 3, wherein said obtaining the stack SIZE SIZE of the present function comprises:
performing instruction analysis from the current PC to the low address direction, and searching for an instruction of an extension stack;
under the condition that the instruction of the extension stack is found, the SIZE SIZE of the function stack is an immediate number in the instruction;
if no instruction to expand the stack is found, then the stack SIZE SIZE is 0.
5. An apparatus for stack backtracking, comprising:
the acquisition module is used for acquiring a memory value at the current FP-4 position;
a determining module, configured to determine, according to a memory value at a current FP-4 location, a stack frame structure type used by a current function, where the stack frame structure type includes: the frame structure comprises a first stack frame structure of ARM, a second stack frame structure of ARM and a third stack frame structure of ARM;
the return module is used for acquiring a return address and a parent function frame pointer FP according to the stack frame structure type;
and the current FP-4 is the memory address of the position where the value of the current function FP moves 4 bytes in the direction of the low address.
6. The apparatus of claim 5,
the determining module is specifically configured to: when the memory value is in the range of the program code segment, determining that the current function uses a first stack frame structure; when the memory value is in the range of the current thread stack, determining that the current function uses a second stack frame structure; and when the memory value is neither in the range of the program code segment nor in the range of the current thread stack, determining that the current function uses a third stack frame structure.
7. The apparatus of claim 5 or 6,
the return module is specifically configured to: for the first stack frame structure, reading a return address from a memory corresponding to FP-4, and reading the FP of the parent function from a memory corresponding to FP-12; for the second stack frame structure, reading a return address from a memory corresponding to the FP, and reading the FP of the parent function from a memory corresponding to the FP-4; for the third stack frame structure, the current function stack SIZE SIZE is calculated, the FP of the parent function is read from FP + SIZE, and the return address is read from FP + SIZE + 4.
8. An apparatus for stack backtracking, comprising:
a memory storing a stack trace-back program;
a processor configured to execute the stack trace back procedure to perform the following operations: acquiring a memory value at the current FP-4 position; determining a stack frame structure type used by a current function according to a memory value at a current FP-4 position, wherein the stack frame structure type comprises: the frame structure comprises a first stack frame structure of ARM, a second stack frame structure of ARM and a third stack frame structure of ARM; acquiring a return address and a parent function frame pointer FP according to the stack frame structure type; and the current FP-4 is the memory address of the position where the value of the current function FP moves 4 bytes in the direction of the low address.
9. A computer-readable storage medium, wherein a stack trace-back program is stored on the computer-readable storage medium, and when executed by a processor, the stack trace-back program implements the steps of the stack trace-back method according to any one of claims 1 to 4.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201710398429.4A CN108984328B (en) | 2017-05-31 | 2017-05-31 | Stack backtracking method and device |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201710398429.4A CN108984328B (en) | 2017-05-31 | 2017-05-31 | Stack backtracking method and device |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN108984328A CN108984328A (en) | 2018-12-11 |
| CN108984328B true CN108984328B (en) | 2021-08-17 |
Family
ID=64501993
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201710398429.4A Active CN108984328B (en) | 2017-05-31 | 2017-05-31 | Stack backtracking method and device |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN108984328B (en) |
Families Citing this family (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN111367588B (en) * | 2018-12-25 | 2023-05-16 | 杭州海康威视数字技术股份有限公司 | Method and device for obtaining stack usage |
| CN112395598B (en) * | 2019-08-15 | 2024-04-19 | 奇安信安全技术(珠海)有限公司 | Protection method, device and equipment for damaged instruction execution sequence |
| CN111144117B (en) * | 2019-12-26 | 2023-08-29 | 同济大学 | Method for disambiguating Chinese address of knowledge graph |
| CN112925718B (en) * | 2021-03-22 | 2023-10-20 | 北京字节跳动网络技术有限公司 | Call stack backtracking method, device, equipment and medium |
| CN113238800B (en) * | 2021-05-25 | 2022-06-28 | 上海安路信息科技股份有限公司 | Stack frame structure and function calling method and system |
Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101122881A (en) * | 2007-09-20 | 2008-02-13 | 福建星网锐捷网络有限公司 | CPU abnormal point positioning diagnosis method based MIPS structure |
| CN101211309A (en) * | 2006-12-29 | 2008-07-02 | 中兴通讯股份有限公司 | Embedded system progress abnormal tracking position-finding method |
| US7870541B1 (en) * | 2004-11-01 | 2011-01-11 | Wind River Systems, Inc. | Context tracing for software with a frame pointer and a stack pointer and with a stack pointer but without a frame pointer |
| CN104484179A (en) * | 2014-12-23 | 2015-04-01 | 上海斐讯数据通信技术有限公司 | Stack recalling method |
Family Cites Families (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US9678821B2 (en) * | 2015-05-06 | 2017-06-13 | International Business Machines Corporation | Operating a trace procedure for a computer program |
-
2017
- 2017-05-31 CN CN201710398429.4A patent/CN108984328B/en active Active
Patent Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US7870541B1 (en) * | 2004-11-01 | 2011-01-11 | Wind River Systems, Inc. | Context tracing for software with a frame pointer and a stack pointer and with a stack pointer but without a frame pointer |
| CN101211309A (en) * | 2006-12-29 | 2008-07-02 | 中兴通讯股份有限公司 | Embedded system progress abnormal tracking position-finding method |
| CN101122881A (en) * | 2007-09-20 | 2008-02-13 | 福建星网锐捷网络有限公司 | CPU abnormal point positioning diagnosis method based MIPS structure |
| CN104484179A (en) * | 2014-12-23 | 2015-04-01 | 上海斐讯数据通信技术有限公司 | Stack recalling method |
Also Published As
| Publication number | Publication date |
|---|---|
| CN108984328A (en) | 2018-12-11 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN108984328B (en) | Stack backtracking method and device | |
| CN107729083B (en) | Method for loading driver and embedded device | |
| US10599413B2 (en) | Method and device for identifying file | |
| KR20140006861A (en) | Processing apparatus, trace unit and diagnostic apparatus | |
| CN104536810B (en) | A kind of method for detecting abnormality and device based on stack | |
| CN107665134A (en) | Page component loading method, device, medium and terminal equipment | |
| CN111124479B (en) | Method and system for analyzing configuration file and electronic equipment | |
| CN112348838B (en) | Method and system for image analysis | |
| CN109885929B (en) | Automatic driving decision planning data reproduction method and device | |
| EP2960777A1 (en) | Data protection method, apparatus and device | |
| CN111652266A (en) | User interface component identification method and device, electronic equipment and storage medium | |
| CN112328298A (en) | Code library cutting method and device for mobile terminal | |
| CN110262948B (en) | Page data monitoring method, device and equipment | |
| CN113064556A (en) | BIOS data storage method, device, equipment and storage medium | |
| CN108874491A (en) | information loading method and device | |
| CN109191379B (en) | Panorama splicing semantic annotation method, system, terminal and storage medium | |
| CN109509467B (en) | Code generation method and device | |
| US8806448B2 (en) | Dynamic instrumentation method and apparatus for tracing and analyzing a program | |
| US20150220425A1 (en) | Test context generation | |
| CN105718214B (en) | The access method and device of fingerprint mask image | |
| CN108415814B (en) | Method for automatically recording field change, application server and computer readable storage medium | |
| CN113051184A (en) | Data reading method and device, electronic equipment and storage medium | |
| CN117112446B (en) | Editor debugging method and device, electronic equipment and medium | |
| CN110727537A (en) | Method and device for uniformly processing response message, computer equipment and storage medium | |
| CN110471695A (en) | Graph annotation batch processing method, storage medium, system |
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 | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant | ||
| TR01 | Transfer of patent right | ||
| TR01 | Transfer of patent right |
Effective date of registration: 20240530 Address after: 611230, No. 99-1, West Section of Hupan Road, Xinglong Street, Tianfu New Area, Chengdu Free Trade Zone, Sichuan Province, China. Attached OL-10-202305003 Patentee after: ZTE Communications (Chengdu) Co.,Ltd. Country or region after: China Address before: 518057 five floor, block A, ZTE communication tower, Nanshan District science and Technology Park, Shenzhen, Guangdong. Patentee before: ZTE Corp. Country or region before: China |