Breakpoints have now been patented

An anonymous reader noted that apparently Breakpoints have now been patented. From the link "A method for debugging including the steps of receiving code having a software breakpoint function therein, running the code for the purpose of debugging, monitoring the code to detect the presence of the software breakpoint function, recognizing the software breakpoint function, determining an action to be performed based on the software breakpoint function, and implementing the action. The present invention also includes an apparatus for implementing the method for debugging and a medium embodying a program of instructions for execution by a device to perform the method for debugging."

Comments

USPTO Link

[MECC]

Here.

Got there from a search at their site...

How Patents Work

[rilister]

Hey people - I read TFA and there's no detail whatsoever attached.

Before y'all get real excited about insane patents:

1) This is a patent application, NOT a granted patent. Hence the serial number beginning 2003 - this means the application was submitted in 2003. It should have been processed now. I'll take a look if I get a spare moment.

2) This is a snippet from the patent abstract, I'd say. It doesn't mean much at all - abstracts are pretty irrelevant to the content of a patent. We have no idea what they are actually patenting from this: it could be an entirely new mechanism for doing this, new code, a genetically engineered cow with the capability of implementing breakpoints.

The abstract means NOTHING - it's often not supposed to. Don't have a cow, guys.

Re:How Patents Work

[karolgajewski]

If you look up the application number in the USPTO, you will see that it has indeed matured to patent: US 7,055,140

The enforcability of this patent, however, is left to the discretion of the patent owner.

hardware debugger

[Anonymous Coward]

its a hardware debugger or so it appears, not a software one, they specifically address pitfalls with software debuggers and why they did this method.

while hardware ones arent totally new, they arent that common either. gdb is immune from this for example since its software only.

the abstract isnt the patent, the title isnt the patent, the claims are the patent. Readers are encouraged to read the claims and not spread FUD because they can.

Re:I think this is a bit different

[escay]

From what I understand (read the invention background section in the patent) This is a patent about the implementation of a breakpoint handling mechanism, not the idea of using breakpoints to debug itself. specifically, conventional breakpoint sends a software interrupt that is either caught by (a) the debugger, pausing/halting program execution or (b) the OS, in case no debugger is present, resulting in a system hang or crash. Also the assembly halt code may vary for different processors.

The patented breakpoint function catches interrupts and handles them in a specific way, irrespective of whether a debugger is running or not, and also issues CPU-indepedent halt codes, marking an improvement over existing techniques.

Karma whoring, you say? I just have a fascination for patents.

Re:Could someone please patent code comments?

[keird]

Visual Basic has had this for years. It's called Stop. When running in the IDE execution breaks at the Stop command just as if you had a breakpoint defined. The command does nothing when running outside of the IDE.

Re:Could someone please patent code comments?

[SL Baur]

No, they're not preprocessor statements. They are calls to actual nop functions (the patent calls them "void" functions which is highly misleading). Some example code:

static void sw_break1(void)
{
}
static void sw_break2(void)
{
}
extern void do_something_with_side_effects(void);
extern int some_function(int, int, int);
void some_buggy_function(int a, b, c)
{
  int d;
 
  do_something_with_side_effects();
  sw_break1();
  d = some_function(a, b, c);
  sw_break2();
}

Now, if you declare the functions sw_break1 and sw_break2 as software breakpoint functions to the debugger and not the function do_something_with_side_effects, the debugger will recognize that the nop calls to sw_break? should do something special and trap them. Since they are nop functions, obviously if the program is not being run under a debugger, nothing special happens and the program doesn't crash.

The way the description is worded, the debugger is expected to be doing the equivalent of single stepping through the program at a source code level looking for calls to special nop functions. When it detects some such, it can perform some (debugger) user defined operation. Because these are specifically software breakpoints, they are built into the program at compile time and are always present whether or not the program is being debugged.

The patent goes on to claim various methods of describing which void functions should be considered special by the debugger, including a broad all parameterless void functions are special. Any required special debug code is linked from a library and hence, this method of debugging allows one to enable and disable breakpoints dynamically in an read-only image executing directly off a ROM.

I'm a programmer not a lawyer and I've never done embedded programming so I haven't much of a clue whether or not there's prior art, but I am certain that gdb or any debugger that modifies the executable image in any way are not within the claims of this patent.

Re:Could someone please patent code comments?

[SL Baur]

So a macro of something like #define SOFTWARE_BREAK asm { int 3; } which I have been using for years is now patented? That's laughable. No, that's not what they patented. The patent covers portable software breakpoints which are detected by mapping a special (void) function called to an action. The patent also covers a variety of methods of describing which void function calls should be trapped by the debugger and a variety of methods by which the name of the special void function call can be mapped into an action to perform.

No assembly is involved, the method is processor agnostic. No open inline code is involved either as the breakpoints must be detectable by software looking for function calls.