CN115145832A - Analysis method for multithreading access track of public data - Google Patents
Analysis method for multithreading access track of public data Download PDFInfo
- Publication number
- CN115145832A CN115145832A CN202211080215.XA CN202211080215A CN115145832A CN 115145832 A CN115145832 A CN 115145832A CN 202211080215 A CN202211080215 A CN 202211080215A CN 115145832 A CN115145832 A CN 115145832A
- Authority
- CN
- China
- Prior art keywords
- breakpoint
- variable
- variables
- source code
- target
- 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.)
- Granted
Links
Images
Classifications
-
- 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/3636—Software debugging by tracing the execution of the program
-
- 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/3624—Software debugging by performing operations on the source code, e.g. via a compiler
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F21/00—Security arrangements for protecting computers, components thereof, programs or data against unauthorised activity
- G06F21/50—Monitoring users, programs or devices to maintain the integrity of platforms, e.g. of processors, firmware or operating systems
- G06F21/57—Certifying or maintaining trusted computer platforms, e.g. secure boots or power-downs, version controls, system software checks, secure updates or assessing vulnerabilities
- G06F21/577—Assessing vulnerabilities and evaluating computer system security
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
- G06F8/73—Program documentation
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Computer Hardware Design (AREA)
- Software Systems (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Computer Security & Cryptography (AREA)
- Quality & Reliability (AREA)
- Computing Systems (AREA)
- Library & Information Science (AREA)
- Debugging And Monitoring (AREA)
Abstract
The invention discloses an analysis method of a multithreading access track of public data, which can increase breakpoints according to semantic annotation information in the process of compiling source codes by modifying a compiler, and can record code execution related information at the breakpoints as required in the process of running binary codes by modifying a debugger, thereby realizing accurate tracking and recording of a target variable execution process.
Description
Technical Field
The invention belongs to the technical field of computers, and particularly relates to an analysis method for a multithreading access track of public data.
Background
In multi-threaded programs, concurrent access to common variables by multiple threads is a common phenomenon. When a plurality of threads access a common variable and have errors, the existing program debugging modes such as breakpoint increasing, single step interactive mode and the like mainly have the following problems: firstly, errors are difficult to reproduce, and because the time and the sequence of the CPU distributed to a certain thread by an operating system have uncertainty, a certain error can be reproduced only by repeated interactive debugging, so that the difficulty of debugging and analysis is increased; secondly, error positioning is time-consuming, after error reproduction, in a single-step interactive debugging mode, when a programmer is required to memorize errors, a plurality of threads access historical scenes before and after the variables, and then the conditions of a call stack and the like of each thread are analyzed, so that the process is complex and time-consuming; thirdly, the log form is not intuitive, the execution process of the program is recorded in the log, however, the content of the log record is very limited, useful information such as a thread call stack and related variables is often lacked, and in addition, the text log needs to be repeatedly checked through log analysis, which increases the difficulty of program debugging and analysis.
Disclosure of Invention
In view of this, the present invention provides a method for analyzing a multithread access trajectory of public data, which is implemented to complete accurate tracking and recording of a target variable execution process based on code execution related information that needs to be recorded in a binary code debugging process.
The invention provides a method for analyzing a multithreading access track of public data, which specifically comprises the following steps:
step 1, determining all variables related to target variables in a source code as target related variables, and adding semantic labels at all the target related variables;
step 2, in the process of compiling the source code by the compiler, identifying target related variables according to semantic labels, acquiring all write operation codes aiming at the target related variables, and adding custom breakpoint statements before and after the write operation codes to generate binary codes; the user-defined breakpoint statement comprises a specific opcode, a variable ID and a source code line number, wherein the specific opcode is a set invalid opcode;
step 3, debugging the binary code by using a debugger, setting an exception handling mark of the processor as an exception after the debugger receives an InVaLidOpCode exception message, and executing step 4 if an invalid opcode related to the exception message is a specific opcode in a user-defined breakpoint statement; otherwise, executing step 5; when the processor throws the exception, carry out step 6;
step 4, recording information of information entities and corresponding relations among the information entities according to the user-defined breakpoint statements to form breakpoint historical data, wherein the information entities comprise breakpoint instruction addresses A, variable IDs, source code line numbers, threads, stack top functions and variables;
step 5, setting an exception handling mark of the processor as continuous execution, skipping an address position B with the length of a user-defined breakpoint statement after the debugger calculates the breakpoint instruction address A, and executing step 3 by taking the instruction address B as a current instruction address if the address position B exists; if the instruction address B does not exist or the processor throws an exception, executing step 6;
step 6, enabling the iteration execution times to be added by 1, if the iteration execution times is less than or equal to a threshold value, executing the step 3, and if not, finishing the debugging execution step 7; if the processor has thrown the exception, finish debugging and carry out step 7;
and 7, completing analysis of variables and threads according to breakpoint historical data.
Further, the target variable in step 1 is described by using a source code file full path, a source code line number and a variable name.
Further, the manner of determining all variables related to the target variable in the source code as the target related variables in step 1 is as follows: a target dependent variable related to the target variable is determined using a taint analysis method.
Further, the manner of determining all variables related to the target variable in the source code as the target related variables in step 1 is as follows: and determining a target related variable related to the target variable by adopting a symbolic execution method.
Further, the user-defined breakpoint statement further includes source code file information, and the source code file information is a hash value of the source code file.
Further, in the step 4, in the process of forming breakpoint history data according to the information of the information entities recorded by the user-defined breakpoint statement and the corresponding relationship between the information entities, the source code file corresponding to the binary code is obtained according to the source code file information.
Further, the process of forming breakpoint history data according to the information of the user-defined breakpoint statement record information entities and the corresponding relationship between the information entities in the step 4 includes the following steps:
step 4.1, acquiring a call stack A of a thread where the breakpoint instruction address A is located, calculating the intersection of a stack top variable address list of the call stack A and a target related variable, and recording all variables in the intersection and current values of the variables;
step 4.2, acquiring the intersection of the variable address list of the call stack top of the other threads except the thread where the breakpoint instruction address A is located and the target related variable, and recording the call stack of the thread, the variables in the intersection and the corresponding current values if the intersection is not empty; if the intersection is empty, no processing is performed.
Further, the way of completing the analysis of the variables and the threads according to the breakpoint history data in the step 7 is as follows: inquiring the time points of the first and last appearance according to the input conditions, and then inquiring the existing entities and the relation thereof by taking the time points as the conditions; when the entity exists but the relation data does not exist, the relation data which contains the entity and is closest to the previous breakpoint time point is taken as a query result.
Further, after the debugging is finished in the step 6, the specific opcode in the custom breakpoint statement in the binary code is modified into a Nop instruction.
Further, after the debugging is finished in the step 6, the semantic annotation in the source code is deleted and then recompiled to generate the binary code.
Has the advantages that:
1. according to the invention, the compiler is modified to increase the breakpoint according to the semantic annotation information in the process of compiling the source code, and the debugger is modified to record the code execution related information at the breakpoint as required in the process of running the binary code, so that the accurate tracking and recording of the target variable execution process can be realized, and the multithread access track aiming at the public data can be determined based on the recorded information, thereby effectively reducing the difficulty of the debugging process and improving the debugging efficiency and precision.
2. The invention effectively reduces the recorded information quantity and optimizes the recorded information by acquiring the call stack of the thread in the processor at the breakpoint instruction address position and selecting the variable which is the same as the target related variable from the stack top variable address list of the call stack to record the variable value, thereby avoiding the problem of excessive resource consumption caused by recording the information of all threads.
Drawings
Fig. 1 is a flowchart of an analysis method for a multi-thread access trajectory of common data according to the present invention.
Detailed Description
The invention is described in detail below by way of example with reference to the accompanying drawings.
The invention provides a method for analyzing a multithreading access track of public data, which has the core idea that: determining a target related variable in a source code to be analyzed according to a set target variable, and adding semantic labels at the target related variable of the source code; inserting breakpoint instructions before and after the semantic labeling position in the process of compiling the source code by a compiler, wherein the breakpoint instructions are designed as specific invalid opcodes which can trigger a processor to generate an exception of which the type is InVaLidOpCode, and then forming a binary code to be analyzed; in the process of running the binary code by a debugger, recording code running related information when the breakpoint is met until an exception occurs or a set iteration number is reached; and finally, completing analysis of the multithreading access track of the public data according to the recorded code operation related information.
The invention provides a method for analyzing a multithread access track of public data, which has a flow shown in figure 1 and comprises the following steps:
step 1, a developer determines a target variable in a source code concerned by the developer, wherein the target variable is described by information such as a source code file full path, a source code line number and a variable name; and determining all variables related to the target variable in the source code as target related variables, and adding semantic annotations at all target related variables in the source code.
Wherein, the semantic annotation added at all the target related variables in the source code can be expressed in the form of "@ Breakkoint", etc.
In vulnerability analysis, a taint analysis method is generally used to mark interested data as taint data, and whether the taint data can affect key program operation or not can be determined by tracking the flow direction of information related to the taint data, so as to mine program vulnerabilities. In the invention, all variables related to the target variable in the source code can be determined to be target related variables by adopting a taint analysis method, namely the target variable is marked as taint data, and the variable information related to the target variable can be obtained by adopting the taint analysis method. Besides, symbol execution and other methods can be adopted to obtain all variables related to the target variable.
And 2, in the process of compiling the source code by the compiler, identifying a target related variable according to semantic annotation, acquiring an address of the target related variable, acquiring all write operation codes aiming at the address, and adding a custom breakpoint statement before and after the write operation codes to newly add breakpoints to obtain a binary code.
The user-defined breakpoint statement comprises a specific opcode, a variable ID, a source code line number and the like, the specific opcode is an invalid opcode set according to needs and is also a unique byte code, and the variable ID is a unique number of a current variable in a target related variable. The invalid opcode refers to an opcode which cannot be identified by a processor (CPU), and when the processor encounters the opcode, an InVaLidOpCode exception is thrown out, and a processing interface for registering the InVaLidOpcode exception in advance by a debugger is required to process the exception. In addition, in order to improve the efficiency of obtaining the source file, the invention can also add source code file information in the user-defined breakpoint statement, the source code file information is the hash value of the source code file, and the debugging code can rapidly obtain the source code file through the corresponding relation between the hash value and the full path of the source code file.
And 3, loading the debugged binary code by using a debugger.
And 4, starting and debugging the debugged binary code by using the debugger, and setting the instruction address of the first line of codes of the debugged binary code as the current instruction address.
Step 5, the processor executes the instruction according to the current instruction address, when the debugger receives the InVaLidOpCode exception, the exception handling mark of the processor is set to be abnormal, if the current invalid opcode is a specific opcode contained in the custom breakpoint statement, the breakpoint is the breakpoint set by the current debugging, and the step 6 is executed; otherwise, not processing the current exception and executing the step 7; when the processor throws an exception, step 8 is performed.
And 6, recording information entities such as breakpoint instruction address A, variable ID, source code line number, thread, stack top function, variable and the like and the mutual corresponding relation among the information entities according to the user-defined breakpoint statement to form breakpoint historical data.
And if the self-defined breakpoint statement contains the source code file information, acquiring a source code file corresponding to the current binary code according to the source code file information.
Step 7, setting the exception handling flag of the processor to be continuously executed, analyzing debugging information of the debugged binary code by the debugger, calculating a breakpoint instruction address A, then skipping an address position B with the length of a user-defined breakpoint statement, and executing step 5 by taking the instruction address B as a current instruction address if the address position B exists; if instruction address B does not exist or the processor throws an exception, step 8 is performed.
Step 8, enabling the iteration execution times to be added by 1, executing step 4 if the iteration execution times are less than or equal to a threshold value, and otherwise ending the debugging execution step 9 of the debugged binary code; if the processor has thrown an exception then the debug execution step 9 of the debuggee binary is ended.
And 9, completing analysis of variables and threads according to the breakpoint historical data.
Wherein, the process of recording the information entity in the step 6 is as follows: when receiving an information entity to be recorded, inquiring whether the current information entity is recorded, if not, adding the current information entity into an information entity list, and simultaneously recording the time of adding a breakpoint; if the information entity attribute is recorded, the related attribute of the information entity is updated only when the information entity attribute changes.
The mutual relations among the information entities comprise three types of relations, namely the corresponding relation between a thread and a stack top function, the corresponding relation between the stack top function and a variable, and the dependency relation between the variable and the variable, and the information entity list takes breakpoint time as a unique index. Further, since the name of the variable does not change during use, only a change in the value of the variable is recorded in order to reduce the storage space.
In addition, in order to avoid excessive resource consumption caused by recording information of all threads, the invention also provides a mode for reducing the recorded information quantity and optimizing the recorded information in step 6, and the method specifically comprises the following steps:
step 6.1, acquiring a call stack A of a thread where the breakpoint instruction address A is located, calculating an intersection of a stack top variable address list of the call stack A and a target related variable, and recording all variables in the intersection and current values of the variables;
step 6.2, acquiring the intersection of the variable address list of the call stack top of other threads except the thread of the breakpoint instruction address A and the target related variable, and if the intersection is not empty, recording the call stack of the thread, the variables in the intersection and the corresponding current values; if the intersection is empty, no processing is performed.
And 6.3, establishing a mapping relation between the variable ID and the information by using the current variable ID as an index for all the information.
Further, the present invention provides the following ways to complete the analysis of the variables and threads according to the breakpoint history data in step 9:
querying according to time points: inquiring data by taking the input time point as a condition, and inquiring existing entities and relations thereof at the time point; when the entity exists and the relation data of the time point does not exist, inquiring the relation data of the previous breakpoint time point which contains the entity and is closest to the time point;
querying according to variables: and inquiring the time points of the first occurrence and the last occurrence of the variable, sequentially inquiring data of each time point in a time point inquiring mode, and analyzing whether the whole history of variable change is abnormal or not.
Querying according to the thread: and inquiring the time points of the first time and the last time of the thread, sequentially inquiring data of each time point in a time point inquiring mode, and analyzing whether the history of the thread access variable is abnormal or not.
Querying according to variable value change history: and 6.3, taking the variable ID in the step 6.3 as a query condition, searching data of the value of the specific variable when the value is modified each time, and analyzing whether the thread for modifying the variable value is abnormal or not and whether the size of the variable value before and after being changed is abnormal or not.
Further, after the debugging is finished, in order to ensure the correctness of the user executing the binary code, the invention provides the following three ways to close the newly added breakpoint: the first is to modify the specific opcode in the self-defined breakpoint statement in the binary code into a Nop instruction; the second method is to delete the semantic annotation in the source code and then recompile the semantic annotation to generate a binary code; the third is that the user ignores the custom breakpoint statement containing a specific opcode, i.e., ignores the breakpoint.
Example (b):
the embodiment is a method for analyzing a multithreading access track of common data, which is provided by the invention, by modifying an LLVM compiler and an LLDB debugger, and specifically includes the following steps:
s1, a developer determines target variables concerned by the source code file, including a full path of the source code file, a line number of the source code and a variable name.
S2, determining a list VariableList of all related variables related to the target variable through taint analysis, and adding semantic annotations (annotation) at all related variables in the source code file, for example adding semantic annotations in the form of @ Breakpoint.
S3, modifying the LLVM compiler to mark @ Breakpoint to each semantic in the source code file, and executing the following operations:
s3.1, recognizing the semantic annotation @ BreakPoint and the variable thereof by the pre-compiling processor, and recognizing all write operation codes aiming at the variable according to the address of the variable and the write operation aiming at the address;
and S3.2, inserting a custom breakpoint statement before and after each write operation code of the variable in the compiling process.
S3.3, establishing a user-defined Breakpoint linked list Breakpoint List [ instruction address, file name and line number ] for storing the related information of the user-defined Breakpoint statement, storing the linked list Breakpoint List in the newly-added Section Breakpoint, and writing the newly-added Section Breakpoint into the tail of the binary code.
S4, modifying the LLDB to realize the following functions:
s4.1, when the LLDB loads the debugged program, identifying the newly added Section Breakpoint break point, and analyzing the newly added Section Breakpoint break point into a custom Breakpoint break list.
S4.2, when the debugged program runs to the user-defined breakpoint statement, the LLDB receives the SIGTRAP signal and the instruction address thereof, the LLDB queries the user-defined breakpoint linked list according to the instruction address, and if corresponding records exist, the LLDB can judge that the user-defined breakpoint is hit.
S4.3, after the breakpoint is hit, setting an exception handling mark of the processor as exception, recording the instruction address of the current breakpoint, and simultaneously, in order to avoid recording information of all threads and reduce the recorded information amount, only recording the following three types of information: recording a call stack of a current thread; recording information of variables which have data write dependency with concerned variables, namely calculating an intersection A of a variable address list of the call stack top of the current thread and the variable list VariableList, and recording all the variables in the A and current values thereof; recording other threads and variable information thereof which have data write dependency with the concerned variable, namely calculating the intersection B of a variable address list of the call stack top of all other threads and the variable list VariableList, if B is not empty, recording the call stack of the thread, and recording all variables and current values thereof in B; if B is empty, the call stack of the thread is not recorded.
And S4.4, setting the exception handling mark of the processor as continuous execution, analyzing debugging information of the debugged program by the LLDB, calculating the instruction address of the next line of codes after the current breakpoint instruction address, and executing the next instruction by the processor according to the instruction address.
S5, starting the debugged program by using the LLDB, circularly executing the codes, and exiting when the iteration times reach a set value; or generating an exception, wherein the exception can be a common exception, or can be a target variable exceeding a set value range, and ending the test.
S6, the information storage process when the breakpoint is hit each time is as follows:
s6.1, storing various information entities, including three types of threads, stack top functions and variables, which are expressed as [ time, id, type, name, property ]; when a new entity arrives, inquiring whether the new entity exists or not, if the new entity does not exist, adding the new entity, and recording the time of adding a breakpoint;
s6.2, storing the relation among information entities, wherein the relation comprises three types of relations including a stack top function owned by a thread, a variable owned by the stack top function, and a dependency relation between the variable and the variable, and the breakpoint time is used as a unique index to establish [ time, id1, id2], [ time, thread ID, functional ID ], [ time, functional ID, varID ] and [ time, varID, varID ], in addition, as the name of the variable does not change during the use, in order to reduce the storage space, the variable only stores the change of the value, and the breakpoint time is used as the index: [ time, varID, value ];
and S6.3, when the breakpoint is hit each time, only recording the related content of the thread which changes, not repeatedly recording the unchanged content, and replacing the unchanged content with data closest to the breakpoint time in subsequent query.
S7, a breakpoint historical data retrieval process:
s7.1, inquiring according to time points: inquiring data by taking the input time point as a condition, and inquiring the entity existing at the time and the relation thereof; when the entity exists and the relation data of the time point does not exist, inquiring the relation data which contains the entity and is closest to the previous breakpoint time point with the time point;
s7.2, inquiring according to the variables: inquiring time points of the first and last occurrence of the variable, and sequentially inquiring data of each time point according to the step 7.1;
s7.3, inquiring according to the threads: and inquiring the time points of the first occurrence and the last occurrence of the thread, and sequentially inquiring the data of each time point according to the step 7.1.
In summary, the above description is only a preferred embodiment of the present invention, and is not intended to limit the scope of the present invention. Any modification, equivalent replacement, or improvement made within the spirit and principle of the present invention should be included in the protection scope of the present invention.
Claims (10)
1. A method for analyzing a multithread access track of public data is characterized by comprising the following steps:
step 1, determining all variables related to target variables in a source code as target related variables, and adding semantic labels at all the target related variables;
step 2, in the process of compiling the source code by the compiler, identifying target related variables according to semantic labels, acquiring all write operation codes aiming at the target related variables, and adding custom breakpoint statements before and after the write operation codes to generate binary codes; the user-defined breakpoint statement comprises a specific opcode, a variable ID and a source code line number, wherein the specific opcode is a set invalid opcode;
step 3, debugging the binary code by using a debugger, setting an exception handling flag of the processor as exception after the debugger receives an InVaLidOpCode exception message, and executing step 4 if an invalid opcode related to the exception message is a specific opcode in a user-defined breakpoint statement; otherwise, executing step 5; when the processor throws the exception, carry out step 6;
step 4, recording information of information entities and corresponding relations among the information entities according to the user-defined breakpoint statements to form breakpoint historical data, wherein the information entities comprise breakpoint instruction addresses A, variable IDs, source code line numbers, threads, stack top functions and variables;
step 5, setting an exception handling flag of the processor as continuous execution, skipping an address position B for defining the length of a breakpoint statement after the debugger calculates the breakpoint instruction address A, and executing step 3 by taking the instruction address B as a current instruction address if the address position B exists; if the instruction address B does not exist or the processor throws an exception, executing the step 6;
step 6, adding 1 to the iteration execution times, executing step 3 if the iteration execution times is less than or equal to a threshold value, and otherwise, finishing the debugging execution step 7; if the processor throws the exception, finishing the step 7 of debugging and executing;
and 7, completing analysis of variables and threads according to breakpoint historical data.
2. The analysis method according to claim 1, wherein the target variable in step 1 is described by a full path of a source code file, a line number of a source code and a variable name.
3. The analysis method according to claim 1, wherein the way of determining all variables related to the target variable in the source code as target-related variables in step 1 is: and determining a target related variable related to the target variable by adopting a taint analysis method.
4. The analysis method according to claim 1, wherein the way of determining all variables related to the target variable in the source code as target-related variables in step 1 is: and determining a target related variable related to the target variable by adopting a symbolic execution method.
5. The parsing method of claim 1, wherein the custom breakpoint statement further comprises source code file information, and wherein the source code file information is a hash value of a source code file.
6. The analysis method according to claim 5, wherein in the step 4, in the process of forming the breakpoint history data according to the information of the user-defined breakpoint statement record information entities and the corresponding relationship between the information entities, the source code file corresponding to the binary code is obtained according to the source code file information.
7. The analysis method according to claim 1, wherein the step 4 of forming breakpoint history data according to the information of the information entities and the corresponding relationship between the information entities recorded by the user-defined breakpoint statement comprises the following steps:
step 4.1, acquiring a call stack A of a thread where the breakpoint instruction address A is located, calculating an intersection of a stack top variable address list of the call stack A and a target related variable, and recording all variables in the intersection and current values of the variables;
step 4.2, acquiring the intersection of the variable address list of the call stack top of the other threads except the thread where the breakpoint instruction address A is located and the target related variable, and recording the call stack of the thread, the variables in the intersection and the corresponding current values if the intersection is not empty; if the intersection is empty, no processing is performed.
8. The analysis method according to claim 1, wherein the way of completing the analysis of the variables and threads according to the breakpoint history data in the step 7 is: inquiring the time points of the first and last appearance according to the input conditions, and inquiring the existing entities and the relation thereof by taking the time points as the conditions; when the entity exists but the relation data does not exist, the relation data which contains the entity and is closest to the time point of the previous breakpoint is taken as a query result.
9. The analysis method according to claim 1, wherein the step 6 modifies a specific opcode in a custom breakpoint statement in the binary code into a Nop instruction after the debugging is finished.
10. The analysis method according to claim 1, wherein the step 6 is to recompile the source code after deleting the semantic annotation after the debugging is finished to generate the binary code.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202211080215.XA CN115145832B (en) | 2022-09-05 | 2022-09-05 | Analysis method for multithreading access track of public data |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202211080215.XA CN115145832B (en) | 2022-09-05 | 2022-09-05 | Analysis method for multithreading access track of public data |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN115145832A true CN115145832A (en) | 2022-10-04 |
| CN115145832B CN115145832B (en) | 2022-11-11 |
Family
ID=83415792
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202211080215.XA Active CN115145832B (en) | 2022-09-05 | 2022-09-05 | Analysis method for multithreading access track of public data |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN115145832B (en) |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN117573565A (en) * | 2024-01-16 | 2024-02-20 | 麒麟软件有限公司 | Debug history information reproduction method, device and storage medium |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN105843776A (en) * | 2015-10-15 | 2016-08-10 | 威盛电子股份有限公司 | Microprocessor and method for safely executing instruction therein |
| US20170199802A1 (en) * | 2016-01-08 | 2017-07-13 | International Business Machines Corporation | Stack pattern breakpoint in cobol |
| CN108268278A (en) * | 2016-12-30 | 2018-07-10 | 英特尔公司 | Processor, method and system with configurable space accelerator |
-
2022
- 2022-09-05 CN CN202211080215.XA patent/CN115145832B/en active Active
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN105843776A (en) * | 2015-10-15 | 2016-08-10 | 威盛电子股份有限公司 | Microprocessor and method for safely executing instruction therein |
| US20170199802A1 (en) * | 2016-01-08 | 2017-07-13 | International Business Machines Corporation | Stack pattern breakpoint in cobol |
| CN108268278A (en) * | 2016-12-30 | 2018-07-10 | 英特尔公司 | Processor, method and system with configurable space accelerator |
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN117573565A (en) * | 2024-01-16 | 2024-02-20 | 麒麟软件有限公司 | Debug history information reproduction method, device and storage medium |
| CN117573565B (en) * | 2024-01-16 | 2024-06-07 | 麒麟软件有限公司 | Debug history information reproduction method, device and storage medium |
Also Published As
| Publication number | Publication date |
|---|---|
| CN115145832B (en) | 2022-11-11 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| Baldoni et al. | A survey of symbolic execution techniques | |
| US11494287B2 (en) | Scalable execution tracing for large program codebases | |
| US8091075B2 (en) | Method and apparatus for breakpoint analysis of computer programming code using unexpected code path conditions | |
| US8732673B2 (en) | Automated debugging system and method | |
| US7571427B2 (en) | Methods for comparing versions of a program | |
| US5713010A (en) | Source line tracking in optimized code | |
| CN102360334B (en) | Dynamic and static combined software security test method | |
| US8464207B2 (en) | System and method for tracking software changes | |
| US8010949B2 (en) | Database breakpoint apparatus and method | |
| Zhang et al. | {APICraft}: Fuzz driver generation for closed-source {SDK} libraries | |
| CN104573503B (en) | The detection method and device that a kind of internal storage access overflows | |
| US20060161892A1 (en) | Systems and methods for determining software package identity during a system build | |
| CN115145832B (en) | Analysis method for multithreading access track of public data | |
| CN115543294B (en) | Method for generating visual dependency tree of dynamic link library on Linux system | |
| Moghadam et al. | Refdetect: A multi-language refactoring detection tool based on string alignment | |
| CN111966578A (en) | Automatic evaluation method for android compatibility defect repair effect | |
| Borodin et al. | Deterministic static analysis | |
| MacLarty et al. | Divide-and-query and subterm dependency tracking in the Mercury declarative debugger | |
| CN116069602B (en) | Worst-case execution time analysis method and worst-case execution time analysis device | |
| CN113296833B (en) | Identification method and device for legal instructions in binary file | |
| Altman et al. | DAISY dynamic binary translation software | |
| Yedidia | Incremental PEG Parsing | |
| Doronin et al. | PROBLEM RESEARCH AND DEVELOPMENT OF A TOOL FOR CHECKING APPLICATION BINARY INTERFACE COMPATIBILITY OF VIRTUAL METHOD TABLES | |
| CN117668785A (en) | Virtual instruction extraction method and system based on symbol execution | |
| Li | Pangine Disassembler: Implementing and Evaluating Non-sequential Code Analysis with Non-chronological Backtracking |
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 |