CN117707919A - Co-range debugging method for Shenwei platform - Google Patents
Co-range debugging method for Shenwei platform Download PDFInfo
- Publication number
- CN117707919A CN117707919A CN202311042794.3A CN202311042794A CN117707919A CN 117707919 A CN117707919 A CN 117707919A CN 202311042794 A CN202311042794 A CN 202311042794A CN 117707919 A CN117707919 A CN 117707919A
- Authority
- CN
- China
- Prior art keywords
- debugging
- delve
- instruction
- program
- debugged
- 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 37
- 238000004458 analytical method Methods 0.000 claims abstract description 11
- 230000004044 response Effects 0.000 claims abstract description 7
- 238000012545 processing Methods 0.000 claims abstract description 6
- 230000006870 function Effects 0.000 claims description 37
- 238000013507 mapping Methods 0.000 claims description 4
- 230000014509 gene expression Effects 0.000 abstract description 3
- 230000008569 process Effects 0.000 description 15
- 238000010586 diagram Methods 0.000 description 3
- 238000005516 engineering process Methods 0.000 description 3
- 238000012986 modification Methods 0.000 description 3
- 230000004048 modification Effects 0.000 description 3
- 230000008859 change Effects 0.000 description 2
- 238000013461 design Methods 0.000 description 2
- 238000011161 development Methods 0.000 description 2
- 238000012546 transfer Methods 0.000 description 2
- 230000006399 behavior Effects 0.000 description 1
- 238000004364 calculation method Methods 0.000 description 1
- 150000001875 compounds Chemical class 0.000 description 1
- 230000007547 defect Effects 0.000 description 1
- 238000002360 preparation method Methods 0.000 description 1
- 230000001960 triggered effect Effects 0.000 description 1
Landscapes
- Debugging And Monitoring (AREA)
Abstract
The invention discloses a supporting program debugging method for a Shenwei platform, which is characterized in that the supporting of a Shenwei platform by a Delve debugging tool is realized through the supporting of a Shenwei platform register, the analysis of Shenwei platform instructions and the supporting program debugging processing, and the Delve debugging tool is utilized to analyze the instructions in a program to be debugged on the Shenwei platform; setting a breakpoint in a program to be debugged by using a Delve debugging tool in response to the breakpoint command; responding to the execution command, and tracking the program to be debugged after starting execution by using a Delve debugging tool; in the debugging mode, responding to a debugging command, checking and setting a program to be debugged by using a Delve debugging tool, and controlling the execution flow of the program. According to the invention, the Delve debugging tool can be used for debugging the coordination environment of the Shenwei platform, so that better understanding of GO runtime, data structure and expression is realized, and the performance of the Shenwei platform in coordination is improved.
Description
Technical Field
The invention relates to a coroutine debugging method oriented to a Shenwei platform, and belongs to the technical field of computers.
Background
The Shenwei platform (SW 64) is a domestic processor platform with completely independent intellectual property rights, and in recent years, with the development of platform technology, the Shenwei platform starts to apply the GO language and the coroutine technology, and GO (also called golang) is an open-source programming language and has the advantages of fast operation, fast development and fast deployment. The GO cooperative thread (GORoutein) is a lightweight thread, runs in a user state, is completely suspended and recovered by the self control of a program, does not need to perform context switching of a system kernel, and can be used for realizing cooperative execution of multiple tasks. Multiple coprocessors can be started through coprocessors for realizing concurrent programming, and the scheduler can switch and alternate operation among the multiple coprocessors, so that different subtasks can be completed in different coprocessors. In addition, the co-program scheduler in the GO schedules runnable co-programs into threads one by one to run, and schedules blocked co-programs out of the threads in time, so that frequent switching of the threads is effectively avoided, and concurrency and efficiency of programs are improved. The coroutine solves the problems of high thread creation and switching consumption performance and high cost and high memory occupation, can maximally utilize the concurrency capability of the processor, and has high execution efficiency.
In the process of actually applying the GO language and the coroutine technology, the GO language debugging and the coroutine debugging are required to be carried out on the program, but the function of a debugging tool which can be used on the Shenwei platform at present is not sound enough, the GO language debugging is supported inaccurately, the coroutine Cheng Jibie debugging is not supported, and the debugging requirement of the Shenwei platform is difficult to be met. At present, the defect of a debugging tool has severely limited the application of a Shenwei platform to GO language and coroutine.
The Delve debugging tool is used as a GO native debugger, can realize GO program debugging and support coroutine debugging, can dynamically analyze programs, and is a simple and functional debugging tool. However, the open source Delve debugging tool only supports X86, arm64 and other platforms, but does not support the Shenwei platform, and how to apply the Delve debugging tool to the Shenwei platform is the key point of the next study.
Disclosure of Invention
In order to solve the problems in the prior art, the invention provides a cooperative debugging method for a Shenwei platform, which enables a Delve debugging tool to support the Shenwei platform through a series of designs, further carries out cooperative debugging on the Shenwei platform through the Delve debugging tool, the method solves the problems that the existing debug tool of the Shenwei platform is inaccurate in GO language debugging and unsupported in coroutine debugging, can realize better understanding of GO runtime, data structures and expressions, and improves completeness and high availability of the Shenwei platform debug tool.
In order to solve the technical problems, the invention adopts the following technical means:
the invention provides a cooperative distance debugging method for Shenwei platform, which comprises the following steps:
loading a file containing a program to be debugged through a Shenwei platform;
analyzing instructions in the file by using a Delve debugging tool based on a pre-defined SW64 disassembly function;
setting a breakpoint in the program to be debugged by using the Delve debugging tool in response to a breakpoint command;
responding to an execution command, executing the program to be debugged on the Shenwei platform, and tracking the program to be debugged after starting to execute by using the Delve debugging tool;
when the program to be debugged is executed to a breakpoint, the program to be debugged pauses to be executed, and enters a debugging mode through the Delve debugging tool;
in a debugging mode, responding to a debugging command, and checking and setting a program to be debugged by using the Delve debugging tool;
after the debugging is finished, controlling the execution flow of the program to be debugged through the Delve debugging tool;
the Delve debugging tool reads and writes various registers in the Shenwei platform according to a preset index by calling a ptrace system.
Further, the setting step of the index is as follows:
and calling the PTRACE_PEEKUSR function by using the PTRACE system to set corresponding indexes for various registers in the Shenwei platform, and connecting the PTRACE system with various registers through the indexes.
Further, defining SW64 disassembly functions with a Delve debug tool includes:
classifying all instructions in the Shenwei platform according to the operation codes of the Shenwei platform instructions, and acquiring the instruction format and the register service condition corresponding to each instruction category;
and defining SW64 disassembly functions according to the mapping relation among the operation codes, the instruction types and the instruction formats of the Shenwei platform instructions.
Further, based on a predefined SW64 disassembly function, resolving the instructions in the file with a Delve debug tool includes:
acquiring an operation code of an instruction to be analyzed by using a Delve debugging tool;
obtaining an instruction category and an instruction format corresponding to the operation code of the instruction to be analyzed according to the SW64 disassembly function;
and according to the instruction format, performing instruction analysis by using a Delve debugging tool to obtain the function code, the register and the corresponding offset information of the instruction.
Further, after the Delve debugging tool is used for carrying out the Shenwei platform instruction analysis, the assembly grammar of the instruction is obtained and is displayed for the user in a plan9 form.
Furthermore, in the debugging mode, the Delve debugging tool performs coroutine scheduling according to a coroutine scheduling policy and an SW64 stack switching policy to complete coroutine debugging processing.
Further, in response to a breakpoint command, setting a breakpoint in the program to be debugged with the Delve debug tool includes:
analyzing a breakpoint command by using the Delve debugging tool to obtain a target address for setting a breakpoint in a program to be debugged;
acquiring an original instruction in the target address and copying and storing the original instruction;
and generating a breakpoint instruction based on a 0x80 system, and replacing an original instruction in the target address by the breakpoint instruction.
Further, after the debugging is finished, responding to a continuous execution command, the program to be debugged starts to continue to execute from the current breakpoint, and the saved original instruction is restored to the target address of the current breakpoint through the Delve debugging tool.
The following advantages can be obtained by adopting the technical means:
the invention provides a co-range debugging method for a Shenwei platform, which realizes a Delve debugging tool on a Shenwei platform architecture through the design of SW64 disassembly functions, indexes of registers and the like, and carries out co-range debugging on a program in the Shenwei platform through the Delve debugging tool, thereby solving the problems that the existing debugging tool of the Shenwei platform is inaccurate in GO language debugging and unsupported in co-range debugging, and improving the completeness and high availability of the debugging tool of the Shenwei platform.
Drawings
FIG. 1 is a schematic diagram of a method for implementing Delve debug tool support Shenwei platform in an embodiment of the present invention;
FIG. 2 is a schematic diagram of a GO co-range scheduling strategy according to an embodiment of the present invention;
FIG. 3 is a schematic flow chart of a coroutine debugging method facing the Shenwei platform in the embodiment of the invention;
FIG. 4 is a diagram of a debug command supported by a Delve debug tool in an embodiment of the present invention.
Detailed Description
The technical scheme of the invention is further described below with reference to the accompanying drawings:
the invention aims to realize the support of the Delve debugging tool on the Shenwei platform so as to solve the problems that the existing debugging tool of the Shenwei platform is inaccurate in GO language debugging and is not supported by cooperative debugging, therefore, the invention needs to realize the support of the Delve debugging tool on the Shenwei platform, as shown in fig. 1, and specifically needs to configure the Delve debugging tool and the Shenwei platform from 3 aspects: (1) Realizing the register support of Delve debugging tools on the Shenwei platform; (2) The Delve debugging tool is used for analyzing the instruction of the Shenwei platform; (3) And the cooperative debugging processing of the Delve debugging tool on the Shenwei platform is realized.
In the prior art, the Delve debugging tool can track the progress through a ptrace system under a linux system, so that the invention realizes the functions of reading and writing of the Delve debugging tool to the SW64register and setting of a special purpose register through the ptrace system.
The Shenwei platform adopts a Shenwei 64 architecture (SW 64 architecture), a built-in linux system is adopted, the SW64 architecture comprises various Registers, the invention defines a register structure body under the SW64 architecture as SW64Registers, and comprises a storage structure of a 64-bit integer register, a 64-bit floating point register and a 256-bit vector register, wherein the width of the first 64 bits of the vector register is the floating point register of the corresponding stored Registers.
In the embodiment of the invention, the Delve debugging tool creates an index by calling the ptrace system, and further reads and writes the SW64register according to the index, and the Delve debugging tool is specific: firstly, calling a PTRACE_PEEKUSR function through a PTRACE system under a SW64linux system to set different indexes for various registers, and realizing the mapping from the PTRACE system to the registers through the indexes; and secondly, calling a ptrace system by using a Delve debugging tool, searching and calling a corresponding register according to the index value, and performing read-write operation on the register.
When the Delve debugging tool is used for coroutine debugging, special registers of the SW64 architecture are required to be set, wherein the special registers comprise a program counter PC, a stack register SP, a link register LR and a frame pointer register FP, wherein SW64 DwarPIPREGNum=32, SW64 DwarpSPRegNum=30, SW64 DwarpLRRegNum=26 and SW64 DwarpBPRegNum=15. In the debugging process, when an instruction is decoded, the program counter PC will point to the next instruction, the stack register SP is used to store the data to be executed, the link register LR is used to store the return address of the subfunction, and the frame register FP is used for connection of stack frames. The debugging process mainly focuses on special registers including a program counter PC and a stack register SP, and the indexes of PTRACE_PEEKUSR/PTRACE_POKEUSR operation mode functions of the program counter PC and the stack register SP in the SW64 architecture are 64 and 30 respectively.
In the embodiment of the invention, the SW64linux system loads an executable program in an ELF format, and judges whether the executable program is the binary of the SW64 architecture by reading the machine magic number 0x 9916. When the Delve debugging tool is used for debugging, the binary file of the debugged object is required to be analyzed, so that the SW64 disassembly function is customized, and then the instruction analysis of the Delve debugging tool on the Shenwei platform is realized based on the defined SW64 disassembly function, and the specific operation is as follows:
1) Defining SW64 disassembly functions. In the Shenwei platform, the instruction length of the instruction is 32 bits, wherein the operation code (opcode) is 6 bits, each register field occupies 5 bits (corresponding to 32 integer, floating point or vector registers), and all instructions can be divided into five main classes according to the operation code: system call instructions, transfer instructions, memory instructions, simple operation instructions, and compound operation instructions, the Delve debug tool in the present invention focuses mainly on transfer to zero and system call instructions. The instructions of different categories correspond to different instruction formats, the instruction formats can help a tool to know what a certain bit or a certain bits in the instructions represent, and the categories of the instructions can be subdivided into the situations of using 0, 1, 2, 3 and 4registers according to the different instruction formats. Based on the above, the invention defines the SW64 disassembly function according to the mapping relation among the operation code, the instruction type and the instruction format of the SW64 instruction.
2) Based on the SW64 disassembly function defined in the step 1), analyzing instructions in an ELF file of the SW64linux system by using a Delve debugging tool, and specifically: the method comprises the steps that an entry of an SW64 disassembly function is defined in a Delve debugging tool, an operation code is obtained from an instruction to be analyzed by the Delve debugging tool, an instruction category and an instruction format corresponding to the operation code are obtained according to the SW64 disassembly function, and instruction analysis is carried out according to the instruction format, so that a function code, a register and corresponding offset information of the instruction are obtained.
In the embodiment of the invention, special instructions are required to be processed and classified, the instructions are set, the operation code is CallInstruction when 0x1 (opcode=0x1), the operation code is RetInstruction when 0x2 (opcode=0x2), and the operation code is JmpInstruction when 0x3, 0x4 or 0x 5. And the like, completing instruction analysis. Finally, the jump setting of the subfunction is needed to be carried out on the CallInstructions, the entry address of the subfunction after the jump is obtained through calculation, other instructions need to be subjected to instruction analysis, and the assembly grammar of the instructions is returned. After the analysis, when the command (disassembly) is disassembled, the command of the SW64 architecture is displayed in an assembly form of the plan9, so that the consistency of assembly display with the golang is ensured.
In the embodiment of the invention, a complete SW64 architecture instruction detailed instruction set and corresponding analysis comprising various detailed instruction formats can be added under the vendor/golang. Org/x/arch/SW64 directory.
The coroutine scheduling strategy of the invention is shown in fig. 2, in which the letter G represents coroutine, the letter P represents processor, and the letter M represents thread. When the SW64 architecture is used for cooperative scheduling, the cooperative can automatically stretch, each cooperative (G) must be bound on a thread (M) of a kernel level to be executed, and each thread is bound with a processor (P), and specifically, the automatic binding is carried out according to the multi-core characteristic of the Shenwei processor. When the thread executes the task, the cooperative program is acquired from the local queue of the corresponding processor, the next cooperative program is acquired after the current cooperative program is executed, and if the local queue of the processor corresponding to the thread is empty, the thread can acquire a new cooperative program from the global queue (including all cooperative programs in the Shenwei platform), or acquire the cooperative program from the local queues of other processors and place the cooperative program in the local queue for running.
In the embodiment of the invention, in order to realize the coroutine debugging processing of the Delve debugging tool on the Shenwei platform, the Delve debugging tool defines a function SW64SwitchStack (), which is switched by a SW64 stack, and a debugging command related to coroutine in the debugging is as follows: gr and grs, and performing different processing according to the function name judgment in the current frame. The invention defines a SW64 stack switching strategy for acquiring the function of the coroutine G executed on the current thread, G is stored in the return value, the structure of the current thread G needs to be read from the thread local storage area, and the structure address of the SW64 architecture G is stored in the frame pointer register FP of the integer register. The cooperative thread and the thread corresponding to the cooperative thread can be switched in the SW64 architecture through the SW64 stack switching strategy, and the functions of all cooperative threads in the current process are supported.
The invention realizes the support of Delve debugging tools on the Shenwei platform through the operation, and on the basis, the invention provides a cooperative debugging method for the Shenwei platform, as shown in fig. 3, which specifically comprises the following steps:
step a, loading an ELF file containing a program to be debugged through a Shenwei platform; in response to the launch command, the Delve debug tool is launched.
In the prior art, the Delve debug tool takes over the execution of processes in the respective platform systems via the ptrace system. The ptrace system is a tool for debugging a process provided by Linux and is mainly used for tracking the process, and provides a method for enabling a parent process to observe the execution of a child process, monitor the tracking process and infiltrate into the interior of a program to check and change registers, data space, instruction space and stack content. In the debugging mode of the invention, the Delve debugging tool is used as a parent process, the program to be debugged is used as a child process, and the parent process takes over all signals of the child process, namely all signals sent to the program to be debugged from an operating system can be captured by the Delve debugging tool.
And b, analyzing instructions in the ELF file by using a Delve debugging tool based on a pre-defined SW64 disassembly function, and completing debugging preparation work. Acquiring an operation code of an instruction to be analyzed by using a Delve debugging tool; obtaining an instruction category and an instruction format corresponding to the operation code of the instruction to be analyzed according to the SW64 disassembly function; and according to the instruction format, performing instruction analysis by using a Delve debugging tool to obtain the function code, the register and the corresponding offset information of the instruction.
And c, after the Delve debugging tool is started, a user can input a command after the prompt, the Delve debugging tool is utilized to judge whether the input command meets the requirement, the required modification is carried out on the command which does not meet the requirement, the Delve debugging tool responds to specific command content to carry out breakpoint setting or debugging operation, and the debugging operation comprises checking and setting a program to be debugged, controlling the execution flow of the program to be debugged and the like. In an embodiment of the present invention, the provided debug commands supported by the Delve tool are shown in FIG. 4.
In step c of the present invention, the user generally needs to input a breakpoint command first, and set a breakpoint before the program to be debugged is executed. The breakpoint is a core function of the Delve debugging tool, and the program interrupt position can be specified by setting the breakpoint in the program to be debugged, and the address, the function name or the file name and the line number of the execution to be interrupted by the debugging tool are specified. The user can directly designate the program to start execution without setting the breakpoint, and if the breakpoint is not set, the program to be debugged can directly execute to the end.
Setting a breakpoint requires inserting a special breakpoint instruction into the binary program to be debugged, suspending execution and returning control to the user each time the debugging tool reaches the breakpoint, waiting for the input of a debug command. In an embodiment of the present invention, the SW64 architecture breakpoint command is a 0x80 system call instruction, defined in the SW64BreakInstruction variable.
The specific operation of setting a breakpoint using the Delve debug tool is as follows: analyzing the breakpoint command by using a Delve debugging tool to obtain a target address, wherein the target address indicates a position where a program to be debugged needs to be interrupted; acquiring an original instruction in a target address, and copying and storing the original instruction; and generating a breakpoint instruction based on the 0x80 system, and replacing an original instruction in the target address by the breakpoint instruction to complete breakpoint setting.
After the breakpoint is set successfully, the Delve debugging tool returns the address for setting the breakpoint and the corresponding specific source code position.
The invention can set a conditional breakpoint (cond) to the program, and can pause the program only for the breakpoint meeting the condition. In addition, the breakpoint supports operations of adding (b), deleting (clear, clearall), and viewing (bp).
After the program to be debugged starts to be executed, the Delve debugging tool loads and tracks the program to be debugged, and records stack frame information of the program to be debugged through a ptrace system. When an executable program in the Shenwei platform is sequentially executed to an instruction at a breakpoint, an interrupt is triggered, an operating system sends a SIGTRAP signal to a debugged program, and after the SIGTRAP signal is captured by a Delve debugging tool through a ptrace system, software interrupt is generated and breakpoint hit judgment is carried out. If the breakpoint hits, the user can debug at the pause, and the original instruction stored before the program is resumed to the target address when the program continues to run.
The program to be debugged is suspended to be executed, and enters a debugging mode, and in the debugging mode, a user can debug the program according to the current debugging requirement and input debugging commands such as stack commands, coroutine commands, register commands, assembly commands, program flow setting commands and the like. And responding to a debugging command input by a user, performing coroutine debugging on a program to be debugged in the Shenwei platform through a Delve debugging tool, checking and setting the program to be debugged, and positioning the behavior and variable change condition of a program segment. After the debugging is finished, controlling the execution flow of the program to be debugged through the Delve debugging tool
In the embodiment of the invention, the checking and setting program comprises command operations such as a checking register (regs), a setting variable (set), a checking memory (x), a display parameter (args), a display/switching thread (tr, threads), a display/switching protocol (gr, grs), display stack information (bt), a checking assembly (disclassemble), a checking source code (list) and the like, and the execution flow of the control program comprises command operations such as a line to a breakpoint or a program termination (c), a jump to the next line (n), a single step execution (step), a single step single instruction execution (si), a jump out of a current function (so), a termination debugging (q) and the like.
The method solves the problem that the Delve debugging tool does not support the Shenwei platform, and the Delve debugging tool can communicate with an operating system on the Shenwei platform through a ptrace system to read and write various registers on the Shenwei platform, analyze instructions of the Shenwei platform and debug and analyze a cooperative scheduling process. The Delve debugging tool is utilized to carry out coroutine debugging on the Shenwei platform, so that the GO language source code debugging requirement can be met, the understanding of GO operation, data structures and expressions is better, and the application capability of Shen Weiping platforms to GO language and coroutine is improved.
The foregoing is merely a preferred embodiment of the present invention, and it should be noted that modifications and variations could be made by those skilled in the art without departing from the technical principles of the present invention, and such modifications and variations should also be regarded as being within the scope of the invention.
Claims (8)
1. The coroutine debugging method for the Shenwei platform is characterized by comprising the following steps of:
loading a file containing a program to be debugged through a Shenwei platform;
analyzing instructions in the file by using a Delve debugging tool based on a pre-defined SW64 disassembly function;
setting a breakpoint in the program to be debugged by using the Delve debugging tool in response to a breakpoint command;
responding to an execution command, executing the program to be debugged on the Shenwei platform, and tracking the program to be debugged after starting to execute by using the Delve debugging tool;
when the program to be debugged is executed to a breakpoint, the program to be debugged pauses to be executed, and enters a debugging mode through the Delve debugging tool;
in a debugging mode, responding to a debugging command, and checking and setting a program to be debugged by using the Delve debugging tool;
after the debugging is finished, controlling the execution flow of the program to be debugged through the Delve debugging tool;
the Delve debugging tool reads and writes various registers in the Shenwei platform according to a preset index by calling a ptrace system.
2. The coroutine debugging method according to claim 1, wherein the setting step of the index is:
and calling the PTRACE_PEEKUSR function by using the PTRACE system to set corresponding indexes for various registers in the Shenwei platform, and connecting the PTRACE system with various registers through the indexes.
3. The coroutine debugging method of claim 1, wherein defining the SW64 disassembly function using a Delve debugging tool comprises:
classifying all instructions in the Shenwei platform according to the operation codes of the Shenwei platform instructions, and acquiring the instruction format and the register service condition corresponding to each instruction category;
and defining SW64 disassembly functions according to the mapping relation among the operation codes, the instruction types and the instruction formats of the Shenwei platform instructions.
4. A coroutine debugging method according to claim 3, wherein parsing the instructions in the file with a Delve debugging tool based on a predefined SW64 disassembly function comprises:
acquiring an operation code of an instruction to be analyzed by using a Delve debugging tool;
obtaining an instruction category and an instruction format corresponding to the operation code of the instruction to be analyzed according to the SW64 disassembly function;
and according to the instruction format, performing instruction analysis by using a Delve debugging tool to obtain the function code, the register and the corresponding offset information of the instruction.
5. A coroutine debugging method according to claim 3, wherein after the Delve debugging tool is used for analyzing the Shenwei platform instruction, the assembly grammar of the instruction is obtained and displayed to the user in a form of a plan 9.
6. The coroutine debugging method according to claim 1, wherein in the debugging mode, the Delve debugging tool performs coroutine scheduling according to a coroutine scheduling policy and an SW64 stack switching policy to complete coroutine debugging processing.
7. The coroutine debugging method according to claim 1, wherein setting a breakpoint in the program to be debugged using the Delve debugging tool in response to a breakpoint command comprises:
analyzing a breakpoint command by using the Delve debugging tool to obtain a target address for setting a breakpoint in a program to be debugged;
acquiring an original instruction in the target address and copying and storing the original instruction;
and generating a breakpoint instruction based on a 0x80 system, and replacing an original instruction in the target address by the breakpoint instruction.
8. The coroutine debugging method according to claim 7, wherein after the debugging is finished, in response to a continue execution command, the program to be debugged continues to execute from the current breakpoint, and the saved original instruction is restored to the target address of the current breakpoint through the Delve debugging tool.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202311042794.3A CN117707919A (en) | 2023-08-17 | 2023-08-17 | Co-range debugging method for Shenwei platform |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202311042794.3A CN117707919A (en) | 2023-08-17 | 2023-08-17 | Co-range debugging method for Shenwei platform |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN117707919A true CN117707919A (en) | 2024-03-15 |
Family
ID=90146725
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202311042794.3A Pending CN117707919A (en) | 2023-08-17 | 2023-08-17 | Co-range debugging method for Shenwei platform |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN117707919A (en) |
-
2023
- 2023-08-17 CN CN202311042794.3A patent/CN117707919A/en active Pending
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US8266608B2 (en) | Post-compile instrumentation of object code for generating execution trace data | |
| JP4901075B2 (en) | Computer-readable medium, method and computing device | |
| US4879646A (en) | Data processing system with a pipelined structure for editing trace memory contents and tracing operations during system debugging | |
| US9152531B2 (en) | Post-compile instrumentation of object code for generating execution trace data | |
| JP2019537782A (en) | System, method and device for vertically integrated instrumentation and trace reconstruction | |
| CN100555218C (en) | Be used to improve the apparatus and method of the simulation velocity of the middle-and-high-ranking language of analogue system on the sheet | |
| US5307504A (en) | System and method for preserving instruction granularity when translating program code from a computer having a first architecture to a computer having a second reduced architecture during the occurrence of interrupts due to asynchronous events | |
| EP2359247B1 (en) | Transforming user script code for debugging | |
| JP4718901B2 (en) | Instruction execution device, debugging method, debugging device, and debugging program | |
| US9766911B2 (en) | Support for a non-native application | |
| US20120011491A1 (en) | Efficient recording and replaying of the execution path of a computer program | |
| JP5905911B2 (en) | Diagnostic code using single-step execution | |
| JPH0734178B2 (en) | Effective error reporting for executing conversion code | |
| US8533683B2 (en) | Stack walking enhancements using sensorpoints | |
| US20040098639A1 (en) | Debugging kernel-loadable modules and suspending and replacing functions in non-microkernel operating systems | |
| US20040168157A1 (en) | System and method for creating a process invocation tree | |
| US11442757B2 (en) | Simulation method and simulation system | |
| CN117707919A (en) | Co-range debugging method for Shenwei platform | |
| JP2008135008A (en) | Program module verification method | |
| CN114780409A (en) | Breakpoint setting method based on program running process, electronic device and storage medium | |
| US20130117732A1 (en) | Technique to improve performance of software breakpoint handling | |
| US7890740B2 (en) | Processor comprising a first and a second mode of operation and method of operating the same | |
| US8732721B2 (en) | Method for reducing trap overhead when executing a guest in a virtual machine | |
| CN112559336A (en) | Method, device and system for adaptively debugging heterogeneous computing chip and mainboard chip | |
| Jämbäck | Evaluation of Real-Time Linux on RISC-V processor architecture |
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 |