I think it should be possible to even implement proper breakpoints in constructors from inside Code::Blocks without actually hacking gdb.
However, it won't be easy at all, and it would require us to include kind of a "micro-codeparser" into the debugger plugin.
First of all, one can use the rbreak command (as pointed out by Yiannis a couple of months back) on the constructor. rbreak sets breakpoints on all functions matching a regular expression. Thus, given the constructor with its exact signature, it should reliably set a breakpoint exactly where it belongs.
The problem with this is that you have to do it by hand. Also, it breaks only a the constructor's entry point, not at a specific line.
Using a "micro-codeparser", one could however count how many lines we are from the entry and call next that many times. The problem with this is that calling next for every souce line is probably the most inefficient way to execute a program, so this must only be done if it is really necessary. Therefore, we would need to be able to determine whether or not a given line is inside a constructor (here goes the micro-codeparser again).
Alternatively (to avoid the confusion about BPs being silently ignored), we could forbid setting line breakpoints in certain places (constructors) and instead introduce a special "break at function entry" feature which takes the function name/signature from the current line, does a rbreak on that one and nothing more. Not perfect, but better than nothing. It would still require kind of a micro-codeparser to decide where to allow "break at function" and where not to allow "break at line".
As a different approach, instead of using rbreak, one could extract the mangled constructor names using objdump and filter out the correct ones by unmangling them again via c++filt.
While this is quite expensive, it might be doable when run only once at startup.
Functions (non-Constructors) will have exactly one version with precisely the same signature, but constructors will have several versions with precisely the same signature. Drop everything that has only one version, cache the rest. This leaves us with a list of all constructor source names and mangled names (fits neatly into a std::multimap).
Now, to set a breakpoint, find each one with the correct source name and signature, and set a breakpoint using the respective mangled name. Setting and clearing breakpoints should be less overhead this way, once the data is in our cache.
I guess, rbreak works in a similar way, too, but it is probably less error-prone...
Yiannis?