In Windbg, can I skip breaking when specific C++ exceptions are thrown? - c++

Question

In Visual Studio, through the dialog at Debug > Exceptions..., you can set specific C++ exceptions types to break on or skip past. In Windbg, turning on breaking for C++ exceptions with sxe eh is all or nothing.
Is there any way to skip breaking on specific C++ exception types? Conversely, is there a way to break on only specific types?

Answer 1

Note: This answer is 32-bit specific, as I haven't yet done much 64-bit debugging. I don't know how much applies to 64-bit.
Assume the following code:
class foo_exception : public std::exception {};
void throw_foo()
{
throw foo_exception();
}
And let's assume you've turned on breaking on first chance exceptions for C++ exceptions: sxe eh
Now when the debugger breaks, your exception record will be on the top of the stack. So if you just want to see what the type is, you can display the exception record info:
0:000> .exr #esp
ExceptionAddress: 751dc42d (KERNELBASE!RaiseException+0x00000058)
ExceptionCode: e06d7363 (C++ EH exception)
ExceptionFlags: 00000001
NumberParameters: 3
Parameter[0]: 19930520
Parameter[1]: 0027f770
Parameter[2]: 0122ada0
pExceptionObject: 0027f770
_s_ThrowInfo : 0122ada0
Type : class foo_exception
Type : class std::exception
Take a look at the current stack, and you can see where this stuff is sitting:
0027f6c4 e06d7363
0027f6c8 00000001
0027f6cc 00000000
0027f6d0 751dc42d KERNELBASE!RaiseException+0x58
0027f6d4 00000003
0027f6d8 19930520
0027f6dc 0027f770
0027f6e0 0122ada0 langD!_TI2?AVfoo_exception
...
So the exception itself is sitting at 0027f770 in this example, as you can see from the .exr output next to pExceptionObject. And you can see that value on the stack at 0027f6dc, or offset from the top of the stack by 0x18, so #esp+18. Let's see what the debugger tells us about that location.
0:000> dpp #esp+18 L1
0027f6dc 0027f770 01225ffc langD!foo_exception::`vftable'
This command says: starting at #esp+18, dump one pointer-sized value, then deref the value found there as a pointer, too, and write the name of any symbol matching that second address. And in this case it found the vtable for the foo_exception class. That tells us that the object at address 0027f770 is a foo_exception. And we can use that information to create an expression for a conditional breakpoint.
We need a way to get the address of the vtable directly, and that looks like this:
#!"langD!foo_exception::`vftable'"
We have to quote it because of the back tick and apostraphe. We also need to pull the desired stack value:
poi(poi(#esp+18))
The poi operator takes an address and returns a pointer-sized value stored there. The first evaluation turns the stack address into the object address, and the second evaluation turns the object address into the vtable address, which we need for comparison. The whole condition looks like this:
#!"langD!foo_exception::`vftable'" == poi(poi(#esp+18))
Now that we can tell if it's a foo_exception, we can skip breaking on them by setting a command to run automatically when the debugger breaks on C++ exceptions:
sxe -c".if ( #!\"langD!foo_exception::`vftable'\" == poi(poi(#esp+18)) ) {gc}" eh
Translation:
break on first chance for C++ exceptions and run a command that:
compares the foo_exception vtable address to the vtable address of the object at #esp+18
if they are the same, issue the gc command, which continues running if the debugger was running when this command was reached
(don't forget to escape the inner quotes)
And if you want to break only for a foo_exception, change the condition from == to !=.
Something to keep in mind is that sometimes exceptions are thrown as a pointer instead of by value, which means you'll need one more poi() around the #esp part of the expression. You'll be able to tell because when you dump the exception record with .exr, the Type will be class foo_expression *. This is completely dependent on the code that throws the exception and not the exception type itself, so you may need to tailor your .if-condition for the situtation.
Lastly, if you want to break on or skip several exception types, it is doable. I would suggest writing a script with the chained .if, .elsif commands and setting thesxe automatic command to $$><path\to\script. Doing a ton of if-condition chaining on one line can be very difficult to read and get right, especially with the extra escaping. A script won't need the extra escaping. Here's a small example:
.if ( #!"langD!foo_exception::`vftable'" == poi(poi(#esp+0x18)) )
{
$$ skip foo_exceptions
gc
}
.elsif ( #!"langD!bar_exception::`vftable'" == poi(poi(#esp+0x18)) )
{
$$ dump the exception to see the error message, then continue running
dt poi(#esp+18) langD!bar_exception
gc
}
.elsif ( #!"langD!baz_exception::`vftable'" == poi(poi(#esp+0x18)) )
{
$$ show the top 10 frames of the stack and then break (because we don't `gc`)
kc 10
}
(Note: Windbg will complain about a script error whenever this runs because it doesn't like a gc command followed by anything else. But it still runs fine)