gdb/common/common-exceptions.h

   1 /* Exception (throw catch) mechanism, for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986-2016 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #ifndef COMMON_EXCEPTIONS_H
  21 #define COMMON_EXCEPTIONS_H
  22
  23 #include <setjmp.h>
  24
  25 /* Reasons for calling throw_exceptions().  NOTE: all reason values
  26    must be less than zero.  enum value 0 is reserved for internal use
  27    as the return value from an initial setjmp().  The function
  28    catch_exceptions() reserves values >= 0 as legal results from its
  29    wrapped function.  */
  30
  31 enum return_reason
  32   {
  33     /* User interrupt.  */
  34     RETURN_QUIT = -2,
  35     /* Any other error.  */
  36     RETURN_ERROR
  37   };
  38
  39 #define RETURN_MASK(reason)     (1 << (int)(-reason))
  40
  41 typedef enum
  42 {
  43   RETURN_MASK_QUIT = RETURN_MASK (RETURN_QUIT),
  44   RETURN_MASK_ERROR = RETURN_MASK (RETURN_ERROR),
  45   RETURN_MASK_ALL = (RETURN_MASK_QUIT | RETURN_MASK_ERROR)
  46 } return_mask;
  47
  48 /* Describe all exceptions.  */
  49
  50 enum errors {
  51   GDB_NO_ERROR,
  52
  53   /* Any generic error, the corresponding text is in
  54      exception.message.  */
  55   GENERIC_ERROR,
  56
  57   /* Something requested was not found.  */
  58   NOT_FOUND_ERROR,
  59
  60   /* Thread library lacks support necessary for finding thread local
  61      storage.  */
  62   TLS_NO_LIBRARY_SUPPORT_ERROR,
  63
  64   /* Load module not found while attempting to find thread local storage.  */
  65   TLS_LOAD_MODULE_NOT_FOUND_ERROR,
  66
  67   /* Thread local storage has not been allocated yet.  */
  68   TLS_NOT_ALLOCATED_YET_ERROR,
  69
  70   /* Something else went wrong while attempting to find thread local
  71      storage.  The ``struct gdb_exception'' message field provides
  72      more detail.  */
  73   TLS_GENERIC_ERROR,
  74
  75   /* Problem parsing an XML document.  */
  76   XML_PARSE_ERROR,
  77
  78   /* Error accessing memory.  */
  79   MEMORY_ERROR,
  80
  81   /* Value not available.  E.g., a register was not collected in a
  82      traceframe.  */
  83   NOT_AVAILABLE_ERROR,
  84
  85   /* Value was optimized out.  Note: if the value was a register, this
  86      means the register was not saved in the frame.  */
  87   OPTIMIZED_OUT_ERROR,
  88
  89   /* DW_OP_GNU_entry_value resolving failed.  */
  90   NO_ENTRY_VALUE_ERROR,
  91
  92   /* Target throwing an error has been closed.  Current command should be
  93      aborted as the inferior state is no longer valid.  */
  94   TARGET_CLOSE_ERROR,
  95
  96   /* An undefined command was executed.  */
  97   UNDEFINED_COMMAND_ERROR,
  98
  99   /* Requested feature, method, mechanism, etc. is not supported.  */
 100   NOT_SUPPORTED_ERROR,
 101
 102   /* The number of candidates generated during line completion has
 103      reached the user's specified limit.  This isn't an error, this exception
 104      is used to halt searching for more completions, but for consistency
 105      "_ERROR" is appended to the name.  */
 106   MAX_COMPLETIONS_REACHED_ERROR,
 107
 108   /* Add more errors here.  */
 109   NR_ERRORS
 110 };
 111
 112 struct gdb_exception
 113 {
 114   enum return_reason reason;
 115   enum errors error;
 116   const char *message;
 117 };
 118
 119 /* The different exception mechanisms that TRY/CATCH can map to.  */
 120
 121 /* Make GDB exceptions use setjmp/longjmp behind the scenes.  This is
 122    the only mode supported when GDB is built as a C program.  */
 123 #define GDB_XCPT_SJMP 1
 124
 125 /* Make GDB exceptions use try/catch behind the scenes.  Can't be made
 126    the default until we handle exceptions crossing foreign frames
 127    (gdb -> readline callback -> gdb -> error).  */
 128 #define GDB_XCPT_TRY 2
 129
 130 /* Specify this mode to build with TRY/CATCH mapped directly to raw
 131    try/catch.  GDB won't work correctly, but building that way catches
 132    code tryin to break/continue out of the try block, along with
 133    spurious code between the TRY and the CATCH block.  */
 134 #define GDB_XCPT_RAW_TRY 3
 135
 136 /* Always use setjmp/longmp, even in C++ mode.  */
 137 #define GDB_XCPT GDB_XCPT_SJMP
 138
 139 /* Functions to drive the sjlj-based exceptions state machine.  Though
 140    declared here by necessity, these functions should be considered
 141    internal to the exceptions subsystem and not used other than via
 142    the TRY/CATCH (or TRY_SJLJ/CATCH_SJLJ) macros defined below.  */
 143
 144 extern jmp_buf *exceptions_state_mc_init (void);
 145 extern int exceptions_state_mc_action_iter (void);
 146 extern int exceptions_state_mc_action_iter_1 (void);
 147 extern int exceptions_state_mc_catch (struct gdb_exception *, int);
 148
 149 /* Same, but for the C++ try/catch-based TRY/CATCH mechanism.  */
 150
 151 #if GDB_XCPT != GDB_XCPT_SJMP
 152 extern void *exception_try_scope_entry (void);
 153 extern void exception_try_scope_exit (void *saved_state);
 154 extern void exception_rethrow (void);
 155 #endif
 156
 157 /* Macro to wrap up standard try/catch behavior.
 158
 159    The double loop lets us correctly handle code "break"ing out of the
 160    try catch block.  (It works as the "break" only exits the inner
 161    "while" loop, the outer for loop detects this handling it
 162    correctly.)  Of course "return" and "goto" are not so lucky.
 163
 164    For instance:
 165
 166    *INDENT-OFF*
 167
 168    TRY
 169      {
 170      }
 171    CATCH (e, RETURN_MASK_ERROR)
 172      {
 173        switch (e.reason)
 174          {
 175            case RETURN_ERROR: ...
 176          }
 177      }
 178    END_CATCH
 179
 180   Note that the SJLJ version of the macros are actually named
 181   TRY_SJLJ/CATCH_SJLJ in order to make it possible to call them even
 182   when TRY/CATCH are mapped to C++ try/catch.  The SJLJ variants are
 183   needed in some cases where gdb exceptions need to cross third-party
 184   library code compiled without exceptions support (e.g.,
 185   readline).  */
 186
 187 #define TRY_SJLJ \
 188      { \
 189        jmp_buf *buf = \
 190          exceptions_state_mc_init (); \
 191        setjmp (*buf); \
 192      } \
 193      while (exceptions_state_mc_action_iter ()) \
 194        while (exceptions_state_mc_action_iter_1 ())
 195
 196 #define CATCH_SJLJ(EXCEPTION, MASK)                             \
 197   {                                                     \
 198     struct gdb_exception EXCEPTION;                             \
 199     if (exceptions_state_mc_catch (&(EXCEPTION), MASK))
 200
 201 #define END_CATCH_SJLJ                          \
 202   }
 203
 204 #if GDB_XCPT == GDB_XCPT_SJMP
 205
 206 /* If using SJLJ-based exceptions for all exceptions, then provide
 207    standard aliases.  */
 208
 209 #define TRY TRY_SJLJ
 210 #define CATCH CATCH_SJLJ
 211 #define END_CATCH END_CATCH_SJLJ
 212
 213 #endif /* GDB_XCPT_SJMP */
 214
 215 #if GDB_XCPT == GDB_XCPT_TRY || GDB_XCPT == GDB_XCPT_RAW_TRY
 216
 217 /* Prevent error/quit during TRY from calling cleanups established
 218    prior to here.  This pops out the scope in either case of normal
 219    exit or exception exit.  */
 220 struct exception_try_scope
 221 {
 222   exception_try_scope ()
 223   {
 224     saved_state = exception_try_scope_entry ();
 225   }
 226   ~exception_try_scope ()
 227   {
 228     exception_try_scope_exit (saved_state);
 229   }
 230
 231   void *saved_state;
 232 };
 233
 234 #if GDB_XCPT == GDB_XCPT_TRY
 235
 236 /* We still need to wrap TRY/CATCH in C++ so that cleanups and C++
 237    exceptions can coexist.  The TRY blocked is wrapped in a
 238    do/while(0) so that break/continue within the block works the same
 239    as in C.  */
 240 #define TRY                                                             \
 241   try                                                                   \
 242     {                                                                   \
 243       exception_try_scope exception_try_scope_instance;                 \
 244       do                                                                \
 245         {
 246
 247 #define CATCH(EXCEPTION, MASK)                                          \
 248         } while (0);                                                    \
 249     }                                                                   \
 250   catch (struct gdb_exception ## _ ## MASK &EXCEPTION)
 251
 252 #define END_CATCH                               \
 253   catch (...)                                   \
 254   {                                             \
 255     exception_rethrow ();                       \
 256   }
 257
 258 #else
 259
 260 #define TRY try
 261 #define CATCH(EXCEPTION, MASK) \
 262   catch (struct gdb_exception ## _ ## MASK &EXCEPTION)
 263 #define END_CATCH
 264
 265 #endif
 266
 267 /* The exception types client code may catch.  They're just shims
 268    around gdb_exception that add nothing but type info.  Which is used
 269    is selected depending on the MASK argument passed to CATCH.  */
 270
 271 struct gdb_exception_RETURN_MASK_ALL : public gdb_exception
 272 {
 273 };
 274
 275 struct gdb_exception_RETURN_MASK_ERROR : public gdb_exception_RETURN_MASK_ALL
 276 {
 277 };
 278
 279 struct gdb_exception_RETURN_MASK_QUIT : public gdb_exception_RETURN_MASK_ALL
 280 {
 281 };
 282
 283 #endif /* GDB_XCPT_TRY || GDB_XCPT_RAW_TRY */
 284
 285 /* *INDENT-ON* */
 286
 287 /* Throw an exception (as described by "struct gdb_exception").  When
 288    GDB is built as a C program, executes a LONG JUMP to the inner most
 289    containing exception handler established using TRY/CATCH.  When
 290    built as a C++ program, throws a C++ exception, using "throw".  */
 291 extern void throw_exception (struct gdb_exception exception)
 292      ATTRIBUTE_NORETURN;
 293
 294 /* Throw an exception by executing a LONG JUMP to the inner most
 295    containing exception handler established using TRY_SJLJ.  Works the
 296    same regardless of whether GDB is built as a C program or a C++
 297    program.  Necessary in some cases where we need to throw GDB
 298    exceptions across third-party library code (e.g., readline).  */
 299 extern void throw_exception_sjlj (struct gdb_exception exception)
 300      ATTRIBUTE_NORETURN;
 301
 302 /* Convenience wrappers around throw_exception that throw GDB
 303    errors.  */
 304 extern void throw_verror (enum errors, const char *fmt, va_list ap)
 305      ATTRIBUTE_NORETURN ATTRIBUTE_PRINTF (2, 0);
 306 extern void throw_vquit (const char *fmt, va_list ap)
 307      ATTRIBUTE_NORETURN ATTRIBUTE_PRINTF (1, 0);
 308 extern void throw_error (enum errors error, const char *fmt, ...)
 309      ATTRIBUTE_NORETURN ATTRIBUTE_PRINTF (2, 3);
 310 extern void throw_quit (const char *fmt, ...)
 311      ATTRIBUTE_NORETURN ATTRIBUTE_PRINTF (1, 2);
 312
 313 /* A pre-defined non-exception.  */
 314 extern const struct gdb_exception exception_none;
 315
 316 #endif /* COMMON_EXCEPTIONS_H */