X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fcommon%2Fcommon-exceptions.h;h=15c85e28ab56d08fdbe8a8451177ce1872d8d2c7;hb=e6a58aa8a70c7fd17d9930e7df8d158a7e3c8c8e;hp=e21713ce894c4f66530fed8115271154515bc36d;hpb=173981bc49c9e8fce9271cb47714952dbe2ec627;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/common/common-exceptions.h b/gdb/common/common-exceptions.h index e21713ce89..15c85e28ab 100644 --- a/gdb/common/common-exceptions.h +++ b/gdb/common/common-exceptions.h @@ -1,6 +1,6 @@ /* Exception (throw catch) mechanism, for GDB, the GNU debugger. - Copyright (C) 1986-2016 Free Software Foundation, Inc. + Copyright (C) 1986-2018 Free Software Foundation, Inc. This file is part of GDB. @@ -21,12 +21,11 @@ #define COMMON_EXCEPTIONS_H #include +#include /* Reasons for calling throw_exceptions(). NOTE: all reason values - must be less than zero. enum value 0 is reserved for internal use - as the return value from an initial setjmp(). The function - catch_exceptions() reserves values >= 0 as legal results from its - wrapped function. */ + must be different from zero. enum value 0 is reserved for internal + use as the return value from an initial setjmp(). */ enum return_reason { @@ -86,7 +85,7 @@ enum errors { means the register was not saved in the frame. */ OPTIMIZED_OUT_ERROR, - /* DW_OP_GNU_entry_value resolving failed. */ + /* DW_OP_entry_value resolving failed. */ NO_ENTRY_VALUE_ERROR, /* Target throwing an error has been closed. Current command should be @@ -118,13 +117,10 @@ struct gdb_exception /* The different exception mechanisms that TRY/CATCH can map to. */ -/* Make GDB exceptions use setjmp/longjmp behind the scenes. This is - the only mode supported when GDB is built as a C program. */ +/* Make GDB exceptions use setjmp/longjmp behind the scenes. */ #define GDB_XCPT_SJMP 1 -/* Make GDB exceptions use try/catch behind the scenes. Can't be made - the default until we stop throwing exceptions from signal - handlers. */ +/* Make GDB exceptions use try/catch behind the scenes. */ #define GDB_XCPT_TRY 2 /* Specify this mode to build with TRY/CATCH mapped directly to raw @@ -133,20 +129,21 @@ struct gdb_exception spurious code between the TRY and the CATCH block. */ #define GDB_XCPT_RAW_TRY 3 -/* Always use setjmp/longmp, even in C++ mode. */ -#define GDB_XCPT GDB_XCPT_SJMP +#define GDB_XCPT GDB_XCPT_TRY -/* Functions to drive the exceptions state machine. Though declared - here by necessity, these functions should be considered internal to - the exceptions subsystem and not used other than via the TRY/CATCH - macros defined below. */ +/* Functions to drive the sjlj-based exceptions state machine. Though + declared here by necessity, these functions should be considered + internal to the exceptions subsystem and not used other than via + the TRY/CATCH (or TRY_SJLJ/CATCH_SJLJ) macros defined below. */ -#if GDB_XCPT == GDB_XCPT_SJMP extern jmp_buf *exceptions_state_mc_init (void); extern int exceptions_state_mc_action_iter (void); extern int exceptions_state_mc_action_iter_1 (void); extern int exceptions_state_mc_catch (struct gdb_exception *, int); -#else + +/* Same, but for the C++ try/catch-based TRY/CATCH mechanism. */ + +#if GDB_XCPT != GDB_XCPT_SJMP extern void *exception_try_scope_entry (void); extern void exception_try_scope_exit (void *saved_state); extern void exception_rethrow (void); @@ -175,11 +172,14 @@ extern void exception_rethrow (void); } END_CATCH - */ + Note that the SJLJ version of the macros are actually named + TRY_SJLJ/CATCH_SJLJ in order to make it possible to call them even + when TRY/CATCH are mapped to C++ try/catch. The SJLJ variants are + needed in some cases where gdb exceptions need to cross third-party + library code compiled without exceptions support (e.g., + readline). */ -#if GDB_XCPT == GDB_XCPT_SJMP - -#define TRY \ +#define TRY_SJLJ \ { \ jmp_buf *buf = \ exceptions_state_mc_init (); \ @@ -188,14 +188,23 @@ extern void exception_rethrow (void); while (exceptions_state_mc_action_iter ()) \ while (exceptions_state_mc_action_iter_1 ()) -#define CATCH(EXCEPTION, MASK) \ +#define CATCH_SJLJ(EXCEPTION, MASK) \ { \ struct gdb_exception EXCEPTION; \ if (exceptions_state_mc_catch (&(EXCEPTION), MASK)) -#define END_CATCH \ +#define END_CATCH_SJLJ \ } +#if GDB_XCPT == GDB_XCPT_SJMP + +/* If using SJLJ-based exceptions for all exceptions, then provide + standard aliases. */ + +#define TRY TRY_SJLJ +#define CATCH CATCH_SJLJ +#define END_CATCH END_CATCH_SJLJ + #endif /* GDB_XCPT_SJMP */ #if GDB_XCPT == GDB_XCPT_TRY || GDB_XCPT == GDB_XCPT_RAW_TRY @@ -220,25 +229,38 @@ struct exception_try_scope #if GDB_XCPT == GDB_XCPT_TRY /* We still need to wrap TRY/CATCH in C++ so that cleanups and C++ - exceptions can coexist. The TRY blocked is wrapped in a - do/while(0) so that break/continue within the block works the same - as in C. */ + exceptions can coexist. + + The TRY blocked is wrapped in a do/while(0) so that break/continue + within the block works the same as in C. + + END_CATCH makes sure that even if the CATCH block doesn't want to + catch the exception, we stop at every frame in the unwind chain to + run its cleanups, which may e.g., have pointers to stack variables + that are going to be destroyed. + + There's an outer scope around the whole TRY/END_CATCH in order to + cause a compilation error if you forget to add the END_CATCH at the + end a TRY/CATCH construct. */ + #define TRY \ - try \ - { \ - exception_try_scope exception_try_scope_instance; \ - do \ - { + { \ + try \ + { \ + exception_try_scope exception_try_scope_instance; \ + do \ + { #define CATCH(EXCEPTION, MASK) \ - } while (0); \ - } \ - catch (struct gdb_exception ## _ ## MASK &EXCEPTION) + } while (0); \ + } \ + catch (struct gdb_exception ## _ ## MASK &EXCEPTION) #define END_CATCH \ - catch (...) \ - { \ - exception_rethrow (); \ + catch (...) \ + { \ + exception_rethrow (); \ + } \ } #else @@ -268,21 +290,42 @@ struct gdb_exception_RETURN_MASK_QUIT : public gdb_exception_RETURN_MASK_ALL #endif /* GDB_XCPT_TRY || GDB_XCPT_RAW_TRY */ -/* *INDENT-ON* */ +/* An exception type that inherits from both std::bad_alloc and a gdb + exception. This is necessary because operator new can only throw + std::bad_alloc, and OTOH, we want exceptions thrown due to memory + allocation error to be caught by all the CATCH/RETURN_MASK_ALL + spread around the codebase. */ -/* Throw an exception (as described by "struct gdb_exception"). Will - execute a LONG JUMP to the inner most containing exception handler - established using catch_exceptions() (or similar). +struct gdb_quit_bad_alloc + : public gdb_exception_RETURN_MASK_QUIT, + public std::bad_alloc +{ + explicit gdb_quit_bad_alloc (gdb_exception ex) + : std::bad_alloc () + { + gdb_exception *self = this; - Code normally throws an exception using error() et.al. For various - reaons, GDB also contains code that throws an exception directly. - For instance, the remote*.c targets contain CNTRL-C signal handlers - that propogate the QUIT event up the exception chain. ``This could - be a good thing or a dangerous thing.'' -- the Existential - Wombat. */ + *self = ex; + } +}; + +/* *INDENT-ON* */ +/* Throw an exception (as described by "struct gdb_exception"), + landing in the inner most containing exception handler established + using TRY/CATCH. */ extern void throw_exception (struct gdb_exception exception) ATTRIBUTE_NORETURN; + +/* Throw an exception by executing a LONG JUMP to the inner most + containing exception handler established using TRY_SJLJ. Necessary + in some cases where we need to throw GDB exceptions across + third-party library code (e.g., readline). */ +extern void throw_exception_sjlj (struct gdb_exception exception) + ATTRIBUTE_NORETURN; + +/* Convenience wrappers around throw_exception that throw GDB + errors. */ extern void throw_verror (enum errors, const char *fmt, va_list ap) ATTRIBUTE_NORETURN ATTRIBUTE_PRINTF (2, 0); extern void throw_vquit (const char *fmt, va_list ap)