1 /* Exception (throw catch) mechanism, for GDB, the GNU debugger. 2 3 Copyright (C) 1986-2015 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 #include "defs.h" 21 #include "exceptions.h" 22 #include "breakpoint.h" 23 #include "target.h" 24 #include "inferior.h" 25 #include "annotate.h" 26 #include "ui-out.h" 27 #include "serial.h" 28 #include "gdbthread.h" 29 30 const struct gdb_exception exception_none = { 0, GDB_NO_ERROR, NULL }; 31 32 void 33 prepare_to_throw_exception (void) 34 { 35 clear_quit_flag (); 36 immediate_quit = 0; 37 } 38 39 static void 40 print_flush (void) 41 { 42 struct serial *gdb_stdout_serial; 43 44 if (deprecated_error_begin_hook) 45 deprecated_error_begin_hook (); 46 47 if (target_supports_terminal_ours ()) 48 target_terminal_ours (); 49 50 /* We want all output to appear now, before we print the error. We 51 have 3 levels of buffering we have to flush (it's possible that 52 some of these should be changed to flush the lower-level ones 53 too): */ 54 55 /* 1. The _filtered buffer. */ 56 if (filtered_printing_initialized ()) 57 wrap_here (""); 58 59 /* 2. The stdio buffer. */ 60 gdb_flush (gdb_stdout); 61 gdb_flush (gdb_stderr); 62 63 /* 3. The system-level buffer. */ 64 gdb_stdout_serial = serial_fdopen (1); 65 if (gdb_stdout_serial) 66 { 67 serial_drain_output (gdb_stdout_serial); 68 serial_un_fdopen (gdb_stdout_serial); 69 } 70 71 annotate_error_begin (); 72 } 73 74 static void 75 print_exception (struct ui_file *file, struct gdb_exception e) 76 { 77 /* KLUGE: cagney/2005-01-13: Write the string out one line at a time 78 as that way the MI's behavior is preserved. */ 79 const char *start; 80 const char *end; 81 82 for (start = e.message; start != NULL; start = end) 83 { 84 end = strchr (start, '\n'); 85 if (end == NULL) 86 fputs_filtered (start, file); 87 else 88 { 89 end++; 90 ui_file_write (file, start, end - start); 91 } 92 } 93 fprintf_filtered (file, "\n"); 94 95 /* Now append the annotation. */ 96 switch (e.reason) 97 { 98 case RETURN_QUIT: 99 annotate_quit (); 100 break; 101 case RETURN_ERROR: 102 /* Assume that these are all errors. */ 103 annotate_error (); 104 break; 105 default: 106 internal_error (__FILE__, __LINE__, _("Bad switch.")); 107 } 108 } 109 110 void 111 exception_print (struct ui_file *file, struct gdb_exception e) 112 { 113 if (e.reason < 0 && e.message != NULL) 114 { 115 print_flush (); 116 print_exception (file, e); 117 } 118 } 119 120 void 121 exception_fprintf (struct ui_file *file, struct gdb_exception e, 122 const char *prefix, ...) 123 { 124 if (e.reason < 0 && e.message != NULL) 125 { 126 va_list args; 127 128 print_flush (); 129 130 /* Print the prefix. */ 131 va_start (args, prefix); 132 vfprintf_filtered (file, prefix, args); 133 va_end (args); 134 135 print_exception (file, e); 136 } 137 } 138 139 /* Call FUNC(UIOUT, FUNC_ARGS) but wrapped within an exception 140 handler. If an exception (enum return_reason) is thrown using 141 throw_exception() than all cleanups installed since 142 catch_exceptions() was entered are invoked, the (-ve) exception 143 value is then returned by catch_exceptions. If FUNC() returns 144 normally (with a positive or zero return value) then that value is 145 returned by catch_exceptions(). It is an internal_error() for 146 FUNC() to return a negative value. 147 148 See exceptions.h for further usage details. 149 150 Must not be called with immediate_quit in effect (bad things might 151 happen, say we got a signal in the middle of a memcpy to quit_return). 152 This is an OK restriction; with very few exceptions immediate_quit can 153 be replaced by judicious use of QUIT. */ 154 155 /* MAYBE: cagney/1999-11-05: catch_errors() in conjunction with 156 error() et al. could maintain a set of flags that indicate the 157 current state of each of the longjmp buffers. This would give the 158 longjmp code the chance to detect a longjmp botch (before it gets 159 to longjmperror()). Prior to 1999-11-05 this wasn't possible as 160 code also randomly used a SET_TOP_LEVEL macro that directly 161 initialized the longjmp buffers. */ 162 163 int 164 catch_exceptions (struct ui_out *uiout, 165 catch_exceptions_ftype *func, 166 void *func_args, 167 return_mask mask) 168 { 169 return catch_exceptions_with_msg (uiout, func, func_args, NULL, mask); 170 } 171 172 int 173 catch_exceptions_with_msg (struct ui_out *func_uiout, 174 catch_exceptions_ftype *func, 175 void *func_args, 176 char **gdberrmsg, 177 return_mask mask) 178 { 179 volatile struct gdb_exception exception; 180 volatile int val = 0; 181 struct ui_out *saved_uiout; 182 183 /* Save and override the global ``struct ui_out'' builder. */ 184 saved_uiout = current_uiout; 185 current_uiout = func_uiout; 186 187 TRY_CATCH (exception, RETURN_MASK_ALL) 188 { 189 val = (*func) (current_uiout, func_args); 190 } 191 192 /* Restore the global builder. */ 193 current_uiout = saved_uiout; 194 195 if (exception.reason < 0 && (mask & RETURN_MASK (exception.reason)) == 0) 196 { 197 /* The caller didn't request that the event be caught. 198 Rethrow. */ 199 throw_exception (exception); 200 } 201 202 exception_print (gdb_stderr, exception); 203 gdb_assert (val >= 0); 204 gdb_assert (exception.reason <= 0); 205 if (exception.reason < 0) 206 { 207 /* If caller wants a copy of the low-level error message, make 208 one. This is used in the case of a silent error whereby the 209 caller may optionally want to issue the message. */ 210 if (gdberrmsg != NULL) 211 { 212 if (exception.message != NULL) 213 *gdberrmsg = xstrdup (exception.message); 214 else 215 *gdberrmsg = NULL; 216 } 217 return exception.reason; 218 } 219 return val; 220 } 221 222 /* This function is superseded by catch_exceptions(). */ 223 224 int 225 catch_errors (catch_errors_ftype *func, void *func_args, char *errstring, 226 return_mask mask) 227 { 228 volatile int val = 0; 229 volatile struct gdb_exception exception; 230 struct ui_out *saved_uiout; 231 232 /* Save the global ``struct ui_out'' builder. */ 233 saved_uiout = current_uiout; 234 235 TRY_CATCH (exception, RETURN_MASK_ALL) 236 { 237 val = func (func_args); 238 } 239 240 /* Restore the global builder. */ 241 current_uiout = saved_uiout; 242 243 if (exception.reason < 0 && (mask & RETURN_MASK (exception.reason)) == 0) 244 { 245 /* The caller didn't request that the event be caught. 246 Rethrow. */ 247 throw_exception (exception); 248 } 249 250 exception_fprintf (gdb_stderr, exception, "%s", errstring); 251 if (exception.reason != 0) 252 return 0; 253 return val; 254 } 255