Legal claims defining the scope of protection. Each claim is shown in both the original legal language and a plain English translation.
1. A debugging apparatus, comprising: a breakpoint setter configured to store a first instruction at a breakpoint in a table and insert a breakpoint instruction at the breakpoint, the breakpoint instruction configured to stop a program currently being executed and comprising current location information of the first instruction; and an instruction executor configured to, in response to the breakpoint being encountered during the execution of the program, execute the first instruction in response to a value of a status bit being a first state, and execute the breakpoint instruction in response to the value of the status bit being a second state, wherein the first instruction is distinct from the breakpoint instruction.
A debugging tool allows setting a breakpoint in a program. When the program reaches the breakpoint, it checks a status bit. If the status bit is in a second state, the debugger runs a "breakpoint instruction" (which stops the program for debugging) and contains location information of the original instruction. If the status bit is in a first state, the debugger runs the original instruction that was replaced by the breakpoint and then continues. The original instruction and breakpoint instruction are different.
2. The debugging apparatus of claim 1 , wherein the breakpoint setter is further configured to: store the first instruction in a first entry of the table; and store a second instruction, which is to be executed after the execution of the first instruction, in a second entry of the table.
The debugging tool from the previous description stores the original instruction at the breakpoint in a table. It also stores a second instruction in the table that should be executed immediately after the first instruction (the original instruction) is executed, allowing for single-stepping through code during debugging and maintaining the correct execution flow.
3. The debugging apparatus of claim 2 , wherein the instruction executor is further configured to: execute the first instruction in the table; and subsequently return an execution order to the second instruction, after the execution of the first instruction, with reference to the second entry.
In the debugging tool which stores instructions in a table, after the first instruction (original instruction at the breakpoint) is executed from the table, the tool uses the second entry in the table to return the program's execution order to the second instruction, ensuring the program continues from the correct point after the original instruction is executed during debugging.
4. The debugging apparatus of claim 1 , wherein the instruction executor is further configured to: in response to the execution of the breakpoint instruction, switch the status bit to the first state.
The debugging tool described earlier, after executing the "breakpoint instruction" (which stops the program), sets the status bit to the first state. This changes the bit state allowing the tool to execute the original instruction at the breakpoint on the next encounter rather than immediately stopping.
5. The debugging apparatus of claim 4 , wherein the instruction executor is further configured to: in response to the execution of the first instruction, switch the status bit to the second state, in response to the status bit being placed in the first state.
In the debugging tool, after executing the original instruction at the breakpoint and only if the status bit was in the first state, the debugging tool changes the status bit to the second state. This prepares the tool to execute the breakpoint instruction and stop again the next time the breakpoint is encountered, allowing debugging to pause again.
6. The debugging apparatus of claim 1 , wherein the instruction executor comprises: a program counter configured to store an execution location of the program; a bit register configured to store the status bit therein; and a controller configured to: maintain a value of the program counter; or change the value of the program counter to indicate the first instruction in the table, in response to the value of the program counter reaching an address of the breakpoint.
The debugging tool includes a program counter that tracks the current execution location in the program. It also has a bit register to store the status bit. A controller either keeps the program counter's value the same (allowing normal execution), or, when the program counter reaches a breakpoint, the controller changes the program counter to point to the original instruction's location in a table.
7. The debugging apparatus of claim 6 , wherein the controller is further configured to change the status bit after the changing of the value of the program counter, to indicate the first instruction in the table.
The debugging tool described previously, after changing the program counter to point to the original instruction in the table (when a breakpoint is hit), also changes the status bit to indicate that the program counter now points to the original instruction within the table. This bit switch helps manage the execution flow between breakpoint instruction and original instruction.
8. A debugging apparatus, comprising: a breakpoint setter configured to store a first instruction at a breakpoint in a table, and insert a breakpoint instruction at the breakpoint, the breakpoint instruction configured to stop a program currently being executed and comprising current location information of the first instruction; a program counter configured to store an execution location of the program; a bit register configured to store a status bit; and a controller configured to maintain the program counter to allow the breakpoint instruction to be executed and switch the status bit to a second state, in response to the program counter pointing to the breakpoint and the status bit being a first state, and change the program counter to point to the location of the first instruction to allow the first instruction to be executed and switch the status bit to the first state, in response to the program counter pointing to the breakpoint and the status bit being the second state, wherein the first instruction is distinct from the breakpoint instruction.
A debugging tool sets a breakpoint and inserts a "breakpoint instruction" that stops the program and stores location of the original instruction. The tool uses a program counter to track the program's location and a bit register for a status bit. If the program counter points to the breakpoint AND the status bit is in a first state, the tool executes the "breakpoint instruction" and sets the status bit to a second state. If the program counter points to the breakpoint AND the status bit is in the second state, the tool changes the program counter to point to the original instruction and sets the status bit to the first state. The original instruction and breakpoint instruction are distinct.
9. The debugging apparatus of claim 8 , wherein the breakpoint setter is further configured to store the first instruction and a second instruction together in the table, the second instruction to be executed after the execution of the first instruction.
In the debugging tool, as described in the previous description which sets a breakpoint, the tool stores the original instruction and a second instruction together in a table. This second instruction is meant to be executed directly after the first instruction. This allows tracking the next instruction to be executed, providing accurate code flow during debugging.
10. The debugging apparatus of claim 9 , wherein the controller is further configured to change the value of the program counter to indicate the second instruction, after the execution of the first instruction.
In the debugging tool that stores instructions in a table, after the original instruction is executed, the controller changes the value of the program counter to point to the second instruction in the table. This ensures program execution continues from the point immediately after the original instruction, maintaining correct program flow.
11. A debugging method, comprising: storing a first instruction at a breakpoint in a table and inserting a breakpoint instruction into the breakpoint, the breakpoint instruction stopping a program currently being executed and comprising current location information of the first instruction; in response to a status bit being placed in a first state, and a program counter pointing to the breakpoint: switching the status bit to a second state; maintaining the program counter; and executing the breakpoint instruction; and in response to the status bit being placed in the second state and the program counter pointing to the breakpoint: switching the status bit to the first state; changing the program counter to point to the location of the first instruction; and executing the first instruction, wherein the first instruction is distinct from the breakpoint instruction.
A debugging method involves storing the original instruction at a breakpoint in a table and inserting a breakpoint instruction. If the status bit is in a first state and the program counter points to the breakpoint, switch the status bit to a second state, maintain the program counter, and execute the breakpoint instruction. If the status bit is in a second state and the program counter points to the breakpoint, switch the status bit to the first state, change the program counter to point to the original instruction's location, and execute the original instruction. The original instruction and breakpoint instruction are distinct.
12. The debugging method of claim 11 , wherein inserting the breakpoint instruction comprises storing the first instruction and a second instruction together in the table, second instruction to be executed after the execution of the first instruction.
The debugging method described earlier stores the original instruction and a second instruction together in the table when inserting the breakpoint instruction. The second instruction is intended to be executed after the original instruction, helping to maintain proper program execution flow during debugging.
13. A non-transitory computer-readable information storage medium storing a program for implementing the method of claim 11 .
A non-transitory computer-readable medium stores a program that implements the debugging method which stores the original instruction at a breakpoint in a table and inserting a breakpoint instruction. If the status bit is in a first state and the program counter points to the breakpoint, switch the status bit to a second state, maintain the program counter, and execute the breakpoint instruction. If the status bit is in a second state and the program counter points to the breakpoint, switch the status bit to the first state, change the program counter to point to the original instruction's location, and execute the original instruction. The original instruction and breakpoint instruction are distinct.
14. A debugging method, comprising: setting a breakpoint in a program; in response to the breakpoint being encountered during the execution of the program, determining whether a status bit is placed in a first state; in response to it being determined that the status bit is placed in the first state: switching the status bit to a second state; executing the breakpoint instruction; and performing debugging of the program, wherein the breakpoint instruction is distinct from a first instruction stored at the breakpoint.
A debugging method involves setting a breakpoint. When the breakpoint is hit, it checks a status bit. If the status bit is in the first state, switch the status bit to a second state, execute a breakpoint instruction, and perform debugging. The breakpoint instruction is different from the original instruction stored at the breakpoint.
15. The debugging method of claim 14 , further comprising, in response to the debugging of the program being complete: resuming the program; and determining whether the status bit is placed in the first state.
The debugging method described previously, after debugging is complete, resumes the program and checks if the status bit is in the first state, determining if the next breakpoint encounter should trigger the breakpoint instruction or the original instruction execution.
16. The debugging method of claim 14 , further comprising, in response to it being determined that the status bit is not placed in the first state: switching the status bit to the first state; executing the first instruction; and executing the second instruction.
In the debugging method, if the status bit is *not* in the first state (meaning it is in some other state), switch the status bit to the first state, execute the original instruction, and execute a second instruction. This executes the original code flow, then the subsequent instruction.
17. A non-transitory computer-readable information storage medium storing a program for implementing the method of claim 14 .
A non-transitory computer-readable medium stores a program for the debugging method of setting a breakpoint, checking a status bit, and executing a breakpoint instruction if the bit is in the first state. It switches the status bit to a second state, executes a breakpoint instruction, and performs debugging. The breakpoint instruction is distinct from the original instruction stored at the breakpoint.
18. A debugging apparatus, comprising: a breakpoint setter configured to set a breakpoint in a program; an instruction executor configured to: in response to the breakpoint being encountered during the execution of the program, determine whether a status bit is placed in a first state; and in response to it being determined that the status bit is placed in the first state: switch the status bit to a second state; execute the breakpoint instruction; and perform debugging of the program, wherein the breakpoint instruction is distinct from a first instruction stored at the breakpoint.
A debugging tool sets a breakpoint in a program. When the breakpoint is hit, the tool checks if a status bit is in a first state. If it is, the tool switches the status bit to a second state, executes a "breakpoint instruction," and performs debugging. The breakpoint instruction is distinct from the original instruction stored at the breakpoint.
19. The debugging apparatus of claim 18 , wherein, in response to the debugging of the program being complete, the instruction executor is further configured to: resume the program; and determine whether the status bit is placed in the first state.
After debugging is complete using the previously described apparatus which sets a breakpoint and utilizes a status bit, the tool resumes the program and checks whether the status bit is in the first state, affecting the next action on hitting the breakpoint.
20. The debugging apparatus of claim 18 , wherein in response to it being determined that the status bit is not placed in the first state, the instruction executor is further configured to: switch the status bit to the first state; execute the first instruction; and execute the second instruction.
Using the debugging apparatus, if the status bit is *not* in the first state upon reaching the breakpoint, the apparatus switches the status bit to the first state, executes the original instruction at that breakpoint, and executes a second instruction. This path executes the original code flow with ability to debug with breakpoints.
Unknown
October 7, 2014
Browse 5M+ US patents with plain-English claim translations and AI-generated analysis.