]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - gdb/infcall.c
Fix typo in skip_prologue_sal's comment.
[thirdparty/binutils-gdb.git] / gdb / infcall.c
CommitLineData
04714b91
AC
1/* Perform an inferior function call, for GDB, the GNU debugger.
2
0b302171 3 Copyright (C) 1986-2012 Free Software Foundation, Inc.
04714b91
AC
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
a9762ec7 9 the Free Software Foundation; either version 3 of the License, or
04714b91
AC
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
a9762ec7 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
04714b91
AC
19
20#include "defs.h"
21#include "breakpoint.h"
573cda03 22#include "tracepoint.h"
04714b91
AC
23#include "target.h"
24#include "regcache.h"
25#include "inferior.h"
26#include "gdb_assert.h"
27#include "block.h"
28#include "gdbcore.h"
29#include "language.h"
9ab9195f 30#include "objfiles.h"
04714b91
AC
31#include "gdbcmd.h"
32#include "command.h"
33#include "gdb_string.h"
b9362cc7 34#include "infcall.h"
96860204 35#include "dummy-frame.h"
a93c0eb6 36#include "ada-lang.h"
347bddb7 37#include "gdbthread.h"
b89667eb
DE
38#include "exceptions.h"
39
40/* If we can't find a function's name from its address,
41 we print this instead. */
42#define RAW_FUNCTION_ADDRESS_FORMAT "at 0x%s"
43#define RAW_FUNCTION_ADDRESS_SIZE (sizeof (RAW_FUNCTION_ADDRESS_FORMAT) \
44 + 2 * sizeof (CORE_ADDR))
04714b91
AC
45
46/* NOTE: cagney/2003-04-16: What's the future of this code?
47
48 GDB needs an asynchronous expression evaluator, that means an
49 asynchronous inferior function call implementation, and that in
50 turn means restructuring the code so that it is event driven. */
51
52/* How you should pass arguments to a function depends on whether it
53 was defined in K&R style or prototype style. If you define a
54 function using the K&R syntax that takes a `float' argument, then
55 callers must pass that argument as a `double'. If you define the
56 function using the prototype syntax, then you must pass the
57 argument as a `float', with no promotion.
58
59 Unfortunately, on certain older platforms, the debug info doesn't
60 indicate reliably how each function was defined. A function type's
61 TYPE_FLAG_PROTOTYPED flag may be clear, even if the function was
62 defined in prototype style. When calling a function whose
63 TYPE_FLAG_PROTOTYPED flag is clear, GDB consults this flag to
64 decide what to do.
65
66 For modern targets, it is proper to assume that, if the prototype
67 flag is clear, that can be trusted: `float' arguments should be
68 promoted to `double'. For some older targets, if the prototype
69 flag is clear, that doesn't tell us anything. The default is to
70 trust the debug information; the user can override this behavior
71 with "set coerce-float-to-double 0". */
72
73static int coerce_float_to_double_p = 1;
920d2a44
AC
74static void
75show_coerce_float_to_double_p (struct ui_file *file, int from_tty,
76 struct cmd_list_element *c, const char *value)
77{
3e43a32a
MS
78 fprintf_filtered (file,
79 _("Coercion of floats to doubles "
80 "when calling functions is %s.\n"),
920d2a44
AC
81 value);
82}
04714b91
AC
83
84/* This boolean tells what gdb should do if a signal is received while
85 in a function called from gdb (call dummy). If set, gdb unwinds
86 the stack and restore the context to what as it was before the
87 call.
88
1777feb0 89 The default is to stop in the frame where the signal was received. */
04714b91 90
ef61f180 91static int unwind_on_signal_p = 0;
920d2a44
AC
92static void
93show_unwind_on_signal_p (struct ui_file *file, int from_tty,
94 struct cmd_list_element *c, const char *value)
95{
3e43a32a
MS
96 fprintf_filtered (file,
97 _("Unwinding of stack if a signal is "
98 "received while in a call dummy is %s.\n"),
920d2a44
AC
99 value);
100}
101
7cd1089b
PM
102/* This boolean tells what gdb should do if a std::terminate call is
103 made while in a function called from gdb (call dummy).
104 As the confines of a single dummy stack prohibit out-of-frame
105 handlers from handling a raised exception, and as out-of-frame
106 handlers are common in C++, this can lead to no handler being found
107 by the unwinder, and a std::terminate call. This is a false positive.
108 If set, gdb unwinds the stack and restores the context to what it
109 was before the call.
110
111 The default is to unwind the frame if a std::terminate call is
112 made. */
113
114static int unwind_on_terminating_exception_p = 1;
115
116static void
117show_unwind_on_terminating_exception_p (struct ui_file *file, int from_tty,
118 struct cmd_list_element *c,
119 const char *value)
120
121{
3e43a32a
MS
122 fprintf_filtered (file,
123 _("Unwind stack if a C++ exception is "
124 "unhandled while in a call dummy is %s.\n"),
7cd1089b
PM
125 value);
126}
04714b91
AC
127
128/* Perform the standard coercions that are specified
a93c0eb6 129 for arguments to be passed to C or Ada functions.
04714b91
AC
130
131 If PARAM_TYPE is non-NULL, it is the expected parameter type.
a93c0eb6
JB
132 IS_PROTOTYPED is non-zero if the function declaration is prototyped.
133 SP is the stack pointer were additional data can be pushed (updating
134 its value as needed). */
04714b91
AC
135
136static struct value *
7788af6d
UW
137value_arg_coerce (struct gdbarch *gdbarch, struct value *arg,
138 struct type *param_type, int is_prototyped, CORE_ADDR *sp)
04714b91 139{
7788af6d 140 const struct builtin_type *builtin = builtin_type (gdbarch);
df407dfe 141 struct type *arg_type = check_typedef (value_type (arg));
52f0bd74 142 struct type *type
04714b91
AC
143 = param_type ? check_typedef (param_type) : arg_type;
144
a93c0eb6
JB
145 /* Perform any Ada-specific coercion first. */
146 if (current_language->la_language == language_ada)
40bc484c 147 arg = ada_convert_actual (arg, type);
a93c0eb6 148
63092375
DJ
149 /* Force the value to the target if we will need its address. At
150 this point, we could allocate arguments on the stack instead of
151 calling malloc if we knew that their addresses would not be
152 saved by the called function. */
153 arg = value_coerce_to_target (arg);
154
04714b91
AC
155 switch (TYPE_CODE (type))
156 {
157 case TYPE_CODE_REF:
fb933624
DJ
158 {
159 struct value *new_value;
160
161 if (TYPE_CODE (arg_type) == TYPE_CODE_REF)
b1af9e97 162 return value_cast_pointers (type, arg, 0);
fb933624
DJ
163
164 /* Cast the value to the reference's target type, and then
165 convert it back to a reference. This will issue an error
166 if the value was not previously in memory - in some cases
167 we should clearly be allowing this, but how? */
168 new_value = value_cast (TYPE_TARGET_TYPE (type), arg);
169 new_value = value_ref (new_value);
170 return new_value;
171 }
04714b91
AC
172 case TYPE_CODE_INT:
173 case TYPE_CODE_CHAR:
174 case TYPE_CODE_BOOL:
175 case TYPE_CODE_ENUM:
176 /* If we don't have a prototype, coerce to integer type if necessary. */
177 if (!is_prototyped)
178 {
7788af6d
UW
179 if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin->builtin_int))
180 type = builtin->builtin_int;
04714b91
AC
181 }
182 /* Currently all target ABIs require at least the width of an integer
183 type for an argument. We may have to conditionalize the following
184 type coercion for future targets. */
7788af6d
UW
185 if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin->builtin_int))
186 type = builtin->builtin_int;
04714b91
AC
187 break;
188 case TYPE_CODE_FLT:
189 if (!is_prototyped && coerce_float_to_double_p)
190 {
7788af6d
UW
191 if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin->builtin_double))
192 type = builtin->builtin_double;
193 else if (TYPE_LENGTH (type) > TYPE_LENGTH (builtin->builtin_double))
194 type = builtin->builtin_long_double;
04714b91
AC
195 }
196 break;
197 case TYPE_CODE_FUNC:
198 type = lookup_pointer_type (type);
199 break;
200 case TYPE_CODE_ARRAY:
201 /* Arrays are coerced to pointers to their first element, unless
202 they are vectors, in which case we want to leave them alone,
203 because they are passed by value. */
204 if (current_language->c_style_arrays)
205 if (!TYPE_VECTOR (type))
206 type = lookup_pointer_type (TYPE_TARGET_TYPE (type));
207 break;
208 case TYPE_CODE_UNDEF:
209 case TYPE_CODE_PTR:
210 case TYPE_CODE_STRUCT:
211 case TYPE_CODE_UNION:
212 case TYPE_CODE_VOID:
213 case TYPE_CODE_SET:
214 case TYPE_CODE_RANGE:
215 case TYPE_CODE_STRING:
04714b91 216 case TYPE_CODE_ERROR:
0d5de010
DJ
217 case TYPE_CODE_MEMBERPTR:
218 case TYPE_CODE_METHODPTR:
04714b91
AC
219 case TYPE_CODE_METHOD:
220 case TYPE_CODE_COMPLEX:
221 default:
222 break;
223 }
224
225 return value_cast (type, arg);
226}
227
07be84bf
JK
228/* Return the return type of a function with its first instruction exactly at
229 the PC address. Return NULL otherwise. */
230
231static struct type *
232find_function_return_type (CORE_ADDR pc)
233{
234 struct symbol *sym = find_pc_function (pc);
235
236 if (sym != NULL && BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) == pc
237 && SYMBOL_TYPE (sym) != NULL)
238 return TYPE_TARGET_TYPE (SYMBOL_TYPE (sym));
239
240 return NULL;
241}
242
04714b91
AC
243/* Determine a function's address and its return type from its value.
244 Calls error() if the function is not valid for calling. */
245
a9fa03de 246CORE_ADDR
04714b91
AC
247find_function_addr (struct value *function, struct type **retval_type)
248{
df407dfe 249 struct type *ftype = check_typedef (value_type (function));
50810684 250 struct gdbarch *gdbarch = get_type_arch (ftype);
7788af6d 251 struct type *value_type = NULL;
09b58708
JK
252 /* Initialize it just to avoid a GCC false warning. */
253 CORE_ADDR funaddr = 0;
04714b91
AC
254
255 /* If it's a member function, just look at the function
256 part of it. */
257
258 /* Determine address to call. */
300f8e10
JK
259 if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
260 || TYPE_CODE (ftype) == TYPE_CODE_METHOD)
261 funaddr = value_address (function);
262 else if (TYPE_CODE (ftype) == TYPE_CODE_PTR)
04714b91
AC
263 {
264 funaddr = value_as_address (function);
265 ftype = check_typedef (TYPE_TARGET_TYPE (ftype));
266 if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
267 || TYPE_CODE (ftype) == TYPE_CODE_METHOD)
300f8e10
JK
268 funaddr = gdbarch_convert_from_func_ptr_addr (gdbarch, funaddr,
269 &current_target);
04714b91 270 }
300f8e10
JK
271 if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
272 || TYPE_CODE (ftype) == TYPE_CODE_METHOD)
07be84bf
JK
273 {
274 value_type = TYPE_TARGET_TYPE (ftype);
275
276 if (TYPE_GNU_IFUNC (ftype))
277 {
278 funaddr = gnu_ifunc_resolve_addr (gdbarch, funaddr);
279
280 /* Skip querying the function symbol if no RETVAL_TYPE has been
281 asked for. */
282 if (retval_type)
283 value_type = find_function_return_type (funaddr);
284 }
285 }
300f8e10 286 else if (TYPE_CODE (ftype) == TYPE_CODE_INT)
04714b91
AC
287 {
288 /* Handle the case of functions lacking debugging info.
1777feb0 289 Their values are characters since their addresses are char. */
04714b91
AC
290 if (TYPE_LENGTH (ftype) == 1)
291 funaddr = value_as_address (value_addr (function));
292 else
2bbe3cc1
DJ
293 {
294 /* Handle function descriptors lacking debug info. */
295 int found_descriptor = 0;
abbb1732 296
87bc73ea 297 funaddr = 0; /* pacify "gcc -Werror" */
2bbe3cc1
DJ
298 if (VALUE_LVAL (function) == lval_memory)
299 {
300 CORE_ADDR nfunaddr;
abbb1732 301
2bbe3cc1
DJ
302 funaddr = value_as_address (value_addr (function));
303 nfunaddr = funaddr;
50810684 304 funaddr = gdbarch_convert_from_func_ptr_addr (gdbarch, funaddr,
2bbe3cc1
DJ
305 &current_target);
306 if (funaddr != nfunaddr)
307 found_descriptor = 1;
308 }
309 if (!found_descriptor)
310 /* Handle integer used as address of a function. */
311 funaddr = (CORE_ADDR) value_as_long (function);
312 }
04714b91
AC
313 }
314 else
8a3fe4f8 315 error (_("Invalid data type for function to be called."));
04714b91 316
7d9b040b
RC
317 if (retval_type != NULL)
318 *retval_type = value_type;
50810684 319 return funaddr + gdbarch_deprecated_function_start_offset (gdbarch);
04714b91
AC
320}
321
d3712828
AC
322/* For CALL_DUMMY_ON_STACK, push a breakpoint sequence that the called
323 function returns to. */
7043d8dc
AC
324
325static CORE_ADDR
326push_dummy_code (struct gdbarch *gdbarch,
82585c72 327 CORE_ADDR sp, CORE_ADDR funaddr,
7043d8dc
AC
328 struct value **args, int nargs,
329 struct type *value_type,
e4fd649a
UW
330 CORE_ADDR *real_pc, CORE_ADDR *bp_addr,
331 struct regcache *regcache)
7043d8dc 332{
50a834af
MK
333 gdb_assert (gdbarch_push_dummy_code_p (gdbarch));
334
335 return gdbarch_push_dummy_code (gdbarch, sp, funaddr,
336 args, nargs, value_type, real_pc, bp_addr,
337 regcache);
7043d8dc
AC
338}
339
b89667eb
DE
340/* Fetch the name of the function at FUNADDR.
341 This is used in printing an error message for call_function_by_hand.
342 BUF is used to print FUNADDR in hex if the function name cannot be
343 determined. It must be large enough to hold formatted result of
344 RAW_FUNCTION_ADDRESS_FORMAT. */
345
346static const char *
347get_function_name (CORE_ADDR funaddr, char *buf, int buf_size)
348{
349 {
350 struct symbol *symbol = find_pc_function (funaddr);
abbb1732 351
b89667eb
DE
352 if (symbol)
353 return SYMBOL_PRINT_NAME (symbol);
354 }
355
356 {
357 /* Try the minimal symbols. */
358 struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (funaddr);
abbb1732 359
b89667eb
DE
360 if (msymbol)
361 return SYMBOL_PRINT_NAME (msymbol);
362 }
363
364 {
365 char *tmp = xstrprintf (_(RAW_FUNCTION_ADDRESS_FORMAT),
366 hex_string (funaddr));
abbb1732 367
b89667eb
DE
368 gdb_assert (strlen (tmp) + 1 <= buf_size);
369 strcpy (buf, tmp);
370 xfree (tmp);
371 return buf;
372 }
373}
374
375/* Subroutine of call_function_by_hand to simplify it.
376 Start up the inferior and wait for it to stop.
377 Return the exception if there's an error, or an exception with
378 reason >= 0 if there's no error.
379
380 This is done inside a TRY_CATCH so the caller needn't worry about
381 thrown errors. The caller should rethrow if there's an error. */
382
383static struct gdb_exception
384run_inferior_call (struct thread_info *call_thread, CORE_ADDR real_pc)
385{
386 volatile struct gdb_exception e;
16c381f0 387 int saved_in_infcall = call_thread->control.in_infcall;
b89667eb 388 ptid_t call_thread_ptid = call_thread->ptid;
b89667eb 389
16c381f0 390 call_thread->control.in_infcall = 1;
c5a4d20b 391
b89667eb
DE
392 clear_proceed_status ();
393
394 disable_watchpoints_before_interactive_call_start ();
16c381f0 395
1777feb0 396 /* We want stop_registers, please... */
16c381f0 397 call_thread->control.proceed_to_finish = 1;
b89667eb 398
b89667eb 399 TRY_CATCH (e, RETURN_MASK_ALL)
3dd5b83d 400 {
a493e3e2 401 proceed (real_pc, GDB_SIGNAL_0, 0);
3dd5b83d
PA
402
403 /* Inferior function calls are always synchronous, even if the
404 target supports asynchronous execution. Do here what
405 `proceed' itself does in sync mode. */
406 if (target_can_async_p () && is_running (inferior_ptid))
407 {
408 wait_for_inferior ();
409 normal_stop ();
410 }
411 }
b89667eb 412
c5a4d20b
PA
413 /* At this point the current thread may have changed. Refresh
414 CALL_THREAD as it could be invalid if its thread has exited. */
e09875d4 415 call_thread = find_thread_ptid (call_thread_ptid);
b89667eb 416
b89667eb
DE
417 enable_watchpoints_after_interactive_call_stop ();
418
419 /* Call breakpoint_auto_delete on the current contents of the bpstat
420 of inferior call thread.
421 If all error()s out of proceed ended up calling normal_stop
422 (and perhaps they should; it already does in the special case
423 of error out of resume()), then we wouldn't need this. */
424 if (e.reason < 0)
425 {
c5a4d20b 426 if (call_thread != NULL)
16c381f0 427 breakpoint_auto_delete (call_thread->control.stop_bpstat);
b89667eb
DE
428 }
429
c5a4d20b 430 if (call_thread != NULL)
16c381f0 431 call_thread->control.in_infcall = saved_in_infcall;
c5a4d20b 432
b89667eb
DE
433 return e;
434}
435
aa7d318d
TT
436/* A cleanup function that calls delete_std_terminate_breakpoint. */
437static void
438cleanup_delete_std_terminate_breakpoint (void *ignore)
439{
440 delete_std_terminate_breakpoint ();
441}
442
04714b91
AC
443/* All this stuff with a dummy frame may seem unnecessarily complicated
444 (why not just save registers in GDB?). The purpose of pushing a dummy
445 frame which looks just like a real frame is so that if you call a
446 function and then hit a breakpoint (get a signal, etc), "backtrace"
447 will look right. Whether the backtrace needs to actually show the
448 stack at the time the inferior function was called is debatable, but
449 it certainly needs to not display garbage. So if you are contemplating
450 making dummy frames be different from normal frames, consider that. */
451
452/* Perform a function call in the inferior.
453 ARGS is a vector of values of arguments (NARGS of them).
454 FUNCTION is a value, the function to be called.
455 Returns a value representing what the function returned.
456 May fail to return, if a breakpoint or signal is hit
457 during the execution of the function.
458
1777feb0 459 ARGS is modified to contain coerced values. */
04714b91
AC
460
461struct value *
462call_function_by_hand (struct value *function, int nargs, struct value **args)
463{
52f0bd74 464 CORE_ADDR sp;
41f1b697 465 struct type *values_type, *target_values_type;
18648a37 466 unsigned char struct_return = 0, hidden_first_param_p = 0;
04714b91 467 CORE_ADDR struct_addr = 0;
16c381f0 468 struct infcall_control_state *inf_status;
04714b91 469 struct cleanup *inf_status_cleanup;
16c381f0 470 struct infcall_suspend_state *caller_state;
04714b91 471 CORE_ADDR funaddr;
04714b91 472 CORE_ADDR real_pc;
df407dfe 473 struct type *ftype = check_typedef (value_type (function));
d585e13a 474 CORE_ADDR bp_addr;
96860204 475 struct frame_id dummy_id;
41f1b697 476 struct cleanup *args_cleanup;
0b9dfe2b
MD
477 struct frame_info *frame;
478 struct gdbarch *gdbarch;
aa7d318d 479 struct cleanup *terminate_bp_cleanup;
b89667eb
DE
480 ptid_t call_thread_ptid;
481 struct gdb_exception e;
b89667eb 482 char name_buf[RAW_FUNCTION_ADDRESS_SIZE];
04714b91 483
4c850810
DJ
484 if (TYPE_CODE (ftype) == TYPE_CODE_PTR)
485 ftype = check_typedef (TYPE_TARGET_TYPE (ftype));
486
04714b91
AC
487 if (!target_has_execution)
488 noprocess ();
489
573cda03
SS
490 if (get_traceframe_number () >= 0)
491 error (_("May not call functions while looking at trace frames."));
492
949dc678 493 if (execution_direction == EXEC_REVERSE)
c2949be0 494 error (_("Cannot call functions in reverse mode."));
949dc678 495
0b9dfe2b
MD
496 frame = get_current_frame ();
497 gdbarch = get_frame_arch (frame);
498
499 if (!gdbarch_push_dummy_call_p (gdbarch))
2e74121d 500 error (_("This target does not support function calls."));
a86c5fc9 501
b89667eb
DE
502 /* A cleanup for the inferior status.
503 This is only needed while we're preparing the inferior function call. */
16c381f0
JK
504 inf_status = save_infcall_control_state ();
505 inf_status_cleanup
506 = make_cleanup_restore_infcall_control_state (inf_status);
04714b91 507
b89667eb
DE
508 /* Save the caller's registers and other state associated with the
509 inferior itself so that they can be restored once the
96860204
AC
510 callee returns. To allow nested calls the registers are (further
511 down) pushed onto a dummy frame stack. Include a cleanup (which
512 is tossed once the regcache has been pushed). */
16c381f0
JK
513 caller_state = save_infcall_suspend_state ();
514 make_cleanup_restore_infcall_suspend_state (caller_state);
04714b91 515
04714b91 516 /* Ensure that the initial SP is correctly aligned. */
ebc7896c 517 {
0b9dfe2b 518 CORE_ADDR old_sp = get_frame_sp (frame);
abbb1732 519
0b9dfe2b 520 if (gdbarch_frame_align_p (gdbarch))
ebc7896c 521 {
0b9dfe2b 522 sp = gdbarch_frame_align (gdbarch, old_sp);
8b148df9
AC
523 /* NOTE: cagney/2003-08-13: Skip the "red zone". For some
524 ABIs, a function can use memory beyond the inner most stack
525 address. AMD64 called that region the "red zone". Skip at
526 least the "red zone" size before allocating any space on
527 the stack. */
0b9dfe2b
MD
528 if (gdbarch_inner_than (gdbarch, 1, 2))
529 sp -= gdbarch_frame_red_zone_size (gdbarch);
8b148df9 530 else
0b9dfe2b 531 sp += gdbarch_frame_red_zone_size (gdbarch);
8b148df9 532 /* Still aligned? */
0b9dfe2b 533 gdb_assert (sp == gdbarch_frame_align (gdbarch, sp));
ebc7896c
AC
534 /* NOTE: cagney/2002-09-18:
535
536 On a RISC architecture, a void parameterless generic dummy
537 frame (i.e., no parameters, no result) typically does not
538 need to push anything the stack and hence can leave SP and
c48a845b 539 FP. Similarly, a frameless (possibly leaf) function does
ebc7896c
AC
540 not push anything on the stack and, hence, that too can
541 leave FP and SP unchanged. As a consequence, a sequence of
542 void parameterless generic dummy frame calls to frameless
543 functions will create a sequence of effectively identical
544 frames (SP, FP and TOS and PC the same). This, not
545 suprisingly, results in what appears to be a stack in an
546 infinite loop --- when GDB tries to find a generic dummy
547 frame on the internal dummy frame stack, it will always
548 find the first one.
549
550 To avoid this problem, the code below always grows the
551 stack. That way, two dummy frames can never be identical.
552 It does burn a few bytes of stack but that is a small price
553 to pay :-). */
ebc7896c
AC
554 if (sp == old_sp)
555 {
0b9dfe2b 556 if (gdbarch_inner_than (gdbarch, 1, 2))
ebc7896c 557 /* Stack grows down. */
0b9dfe2b 558 sp = gdbarch_frame_align (gdbarch, old_sp - 1);
ebc7896c
AC
559 else
560 /* Stack grows up. */
0b9dfe2b 561 sp = gdbarch_frame_align (gdbarch, old_sp + 1);
ebc7896c 562 }
0e095b7e
JK
563 /* SP may have underflown address zero here from OLD_SP. Memory access
564 functions will probably fail in such case but that is a target's
565 problem. */
ebc7896c
AC
566 }
567 else
a59fe496
AC
568 /* FIXME: cagney/2002-09-18: Hey, you loose!
569
8b148df9
AC
570 Who knows how badly aligned the SP is!
571
572 If the generic dummy frame ends up empty (because nothing is
573 pushed) GDB won't be able to correctly perform back traces.
574 If a target is having trouble with backtraces, first thing to
1777feb0 575 do is add FRAME_ALIGN() to the architecture vector. If that
669fac23 576 fails, try dummy_id().
8b148df9
AC
577
578 If the ABI specifies a "Red Zone" (see the doco) the code
579 below will quietly trash it. */
ebc7896c
AC
580 sp = old_sp;
581 }
04714b91 582
df407dfe 583 funaddr = find_function_addr (function, &values_type);
7788af6d
UW
584 if (!values_type)
585 values_type = builtin_type (gdbarch)->builtin_int;
586
df407dfe 587 CHECK_TYPEDEF (values_type);
04714b91 588
41f1b697
DJ
589 /* Are we returning a value using a structure return (passing a
590 hidden argument pointing to storage) or a normal value return?
591 There are two cases: language-mandated structure return and
592 target ABI structure return. The variable STRUCT_RETURN only
593 describes the latter. The language version is handled by passing
594 the return location as the first parameter to the function,
595 even preceding "this". This is different from the target
596 ABI version, which is target-specific; for instance, on ia64
597 the first argument is passed in out0 but the hidden structure
598 return pointer would normally be passed in r8. */
599
18648a37 600 if (gdbarch_return_in_first_hidden_param_p (gdbarch, values_type))
41f1b697 601 {
18648a37 602 hidden_first_param_p = 1;
04714b91 603
41f1b697
DJ
604 /* Tell the target specific argument pushing routine not to
605 expect a value. */
48319d1f 606 target_values_type = builtin_type (gdbarch)->builtin_void;
41f1b697
DJ
607 }
608 else
609 {
6a3a010b 610 struct_return = using_struct_return (gdbarch, function, values_type);
41f1b697
DJ
611 target_values_type = values_type;
612 }
04714b91 613
7043d8dc
AC
614 /* Determine the location of the breakpoint (and possibly other
615 stuff) that the called function will return to. The SPARC, for a
616 function returning a structure or union, needs to make space for
617 not just the breakpoint but also an extra word containing the
618 size (?) of the structure being passed. */
619
0b9dfe2b 620 switch (gdbarch_call_dummy_location (gdbarch))
04714b91
AC
621 {
622 case ON_STACK:
a14dd77e
JK
623 {
624 const gdb_byte *bp_bytes;
625 CORE_ADDR bp_addr_as_address;
626 int bp_size;
627
628 /* Be careful BP_ADDR is in inferior PC encoding while
629 BP_ADDR_AS_ADDRESS is a plain memory address. */
630
631 sp = push_dummy_code (gdbarch, sp, funaddr, args, nargs,
632 target_values_type, &real_pc, &bp_addr,
633 get_current_regcache ());
634
635 /* Write a legitimate instruction at the point where the infcall
636 breakpoint is going to be inserted. While this instruction
637 is never going to be executed, a user investigating the
638 memory from GDB would see this instruction instead of random
639 uninitialized bytes. We chose the breakpoint instruction
640 as it may look as the most logical one to the user and also
641 valgrind 3.7.0 needs it for proper vgdb inferior calls.
642
643 If software breakpoints are unsupported for this target we
644 leave the user visible memory content uninitialized. */
645
646 bp_addr_as_address = bp_addr;
647 bp_bytes = gdbarch_breakpoint_from_pc (gdbarch, &bp_addr_as_address,
648 &bp_size);
649 if (bp_bytes != NULL)
650 write_memory (bp_addr_as_address, bp_bytes, bp_size);
651 }
7043d8dc 652 break;
5931a2fa
JK
653 case AT_ENTRY_POINT:
654 {
655 CORE_ADDR dummy_addr;
656
657 real_pc = funaddr;
658 dummy_addr = entry_point_address ();
a14dd77e 659
5931a2fa 660 /* A call dummy always consists of just a single breakpoint, so
a14dd77e
JK
661 its address is the same as the address of the dummy.
662
663 The actual breakpoint is inserted separatly so there is no need to
664 write that out. */
5931a2fa
JK
665 bp_addr = dummy_addr;
666 break;
667 }
04714b91 668 default:
e2e0b3e5 669 internal_error (__FILE__, __LINE__, _("bad switch"));
04714b91
AC
670 }
671
04714b91 672 if (nargs < TYPE_NFIELDS (ftype))
2e74121d 673 error (_("Too few arguments in function call."));
04714b91 674
ebc7896c
AC
675 {
676 int i;
abbb1732 677
ebc7896c
AC
678 for (i = nargs - 1; i >= 0; i--)
679 {
680 int prototyped;
681 struct type *param_type;
682
683 /* FIXME drow/2002-05-31: Should just always mark methods as
684 prototyped. Can we respect TYPE_VARARGS? Probably not. */
685 if (TYPE_CODE (ftype) == TYPE_CODE_METHOD)
686 prototyped = 1;
687 else if (i < TYPE_NFIELDS (ftype))
688 prototyped = TYPE_PROTOTYPED (ftype);
689 else
690 prototyped = 0;
691
692 if (i < TYPE_NFIELDS (ftype))
693 param_type = TYPE_FIELD_TYPE (ftype, i);
694 else
695 param_type = NULL;
41f1b697 696
7788af6d
UW
697 args[i] = value_arg_coerce (gdbarch, args[i],
698 param_type, prototyped, &sp);
ebc7896c 699
41f1b697
DJ
700 if (param_type != NULL && language_pass_by_reference (param_type))
701 args[i] = value_addr (args[i]);
ebc7896c
AC
702 }
703 }
04714b91 704
04714b91
AC
705 /* Reserve space for the return structure to be written on the
706 stack, if necessary. Make certain that the value is correctly
1777feb0 707 aligned. */
04714b91 708
18648a37 709 if (struct_return || hidden_first_param_p)
04714b91 710 {
df407dfe 711 int len = TYPE_LENGTH (values_type);
abbb1732 712
0b9dfe2b 713 if (gdbarch_inner_than (gdbarch, 1, 2))
04714b91
AC
714 {
715 /* Stack grows downward. Align STRUCT_ADDR and SP after
716 making space for the return value. */
717 sp -= len;
0b9dfe2b
MD
718 if (gdbarch_frame_align_p (gdbarch))
719 sp = gdbarch_frame_align (gdbarch, sp);
04714b91
AC
720 struct_addr = sp;
721 }
722 else
723 {
724 /* Stack grows upward. Align the frame, allocate space, and
1777feb0 725 then again, re-align the frame??? */
0b9dfe2b
MD
726 if (gdbarch_frame_align_p (gdbarch))
727 sp = gdbarch_frame_align (gdbarch, sp);
04714b91
AC
728 struct_addr = sp;
729 sp += len;
0b9dfe2b
MD
730 if (gdbarch_frame_align_p (gdbarch))
731 sp = gdbarch_frame_align (gdbarch, sp);
04714b91
AC
732 }
733 }
734
18648a37 735 if (hidden_first_param_p)
41f1b697
DJ
736 {
737 struct value **new_args;
738
739 /* Add the new argument to the front of the argument list. */
740 new_args = xmalloc (sizeof (struct value *) * (nargs + 1));
741 new_args[0] = value_from_pointer (lookup_pointer_type (values_type),
742 struct_addr);
743 memcpy (&new_args[1], &args[0], sizeof (struct value *) * nargs);
744 args = new_args;
745 nargs++;
746 args_cleanup = make_cleanup (xfree, args);
747 }
748 else
749 args_cleanup = make_cleanup (null_cleanup, NULL);
750
04714b91
AC
751 /* Create the dummy stack frame. Pass in the call dummy address as,
752 presumably, the ABI code knows where, in the call dummy, the
753 return address should be pointed. */
0b9dfe2b
MD
754 sp = gdbarch_push_dummy_call (gdbarch, function, get_current_regcache (),
755 bp_addr, nargs, args,
594f7785 756 sp, struct_return, struct_addr);
04714b91 757
41f1b697
DJ
758 do_cleanups (args_cleanup);
759
96860204
AC
760 /* Set up a frame ID for the dummy frame so we can pass it to
761 set_momentary_breakpoint. We need to give the breakpoint a frame
762 ID so that the breakpoint code can correctly re-identify the
763 dummy breakpoint. */
8241eaa6 764 /* Sanity. The exact same SP value is returned by PUSH_DUMMY_CALL,
669fac23 765 saved as the dummy-frame TOS, and used by dummy_id to form
8241eaa6 766 the frame ID's stack address. */
96860204 767 dummy_id = frame_id_build (sp, bp_addr);
04714b91 768
74cfe982
AC
769 /* Create a momentary breakpoint at the return address of the
770 inferior. That way it breaks when it returns. */
04714b91 771
74cfe982 772 {
e2e4d78b 773 struct breakpoint *bpt, *longjmp_b;
74cfe982 774 struct symtab_and_line sal;
abbb1732 775
74cfe982 776 init_sal (&sal); /* initialize to zeroes */
6c95b8df 777 sal.pspace = current_program_space;
74cfe982
AC
778 sal.pc = bp_addr;
779 sal.section = find_pc_overlay (sal.pc);
8241eaa6
AC
780 /* Sanity. The exact same SP value is returned by
781 PUSH_DUMMY_CALL, saved as the dummy-frame TOS, and used by
669fac23 782 dummy_id to form the frame ID's stack address. */
a6d9a66e 783 bpt = set_momentary_breakpoint (gdbarch, sal, dummy_id, bp_call_dummy);
c70a6932
JK
784
785 /* set_momentary_breakpoint invalidates FRAME. */
786 frame = NULL;
787
74cfe982 788 bpt->disposition = disp_del;
e2e4d78b
JK
789 gdb_assert (bpt->related_breakpoint == bpt);
790
791 longjmp_b = set_longjmp_breakpoint_for_call_dummy ();
792 if (longjmp_b)
793 {
794 /* Link BPT into the chain of LONGJMP_B. */
795 bpt->related_breakpoint = longjmp_b;
796 while (longjmp_b->related_breakpoint != bpt->related_breakpoint)
797 longjmp_b = longjmp_b->related_breakpoint;
798 longjmp_b->related_breakpoint = bpt;
799 }
74cfe982 800 }
04714b91 801
7cd1089b
PM
802 /* Create a breakpoint in std::terminate.
803 If a C++ exception is raised in the dummy-frame, and the
804 exception handler is (normally, and expected to be) out-of-frame,
805 the default C++ handler will (wrongly) be called in an inferior
806 function call. This is wrong, as an exception can be normally
807 and legally handled out-of-frame. The confines of the dummy frame
808 prevent the unwinder from finding the correct handler (or any
809 handler, unless it is in-frame). The default handler calls
810 std::terminate. This will kill the inferior. Assert that
811 terminate should never be called in an inferior function
812 call. Place a momentary breakpoint in the std::terminate function
813 and if triggered in the call, rewind. */
814 if (unwind_on_terminating_exception_p)
aa7d318d 815 set_std_terminate_breakpoint ();
7cd1089b 816
96860204
AC
817 /* Everything's ready, push all the info needed to restore the
818 caller (and identify the dummy-frame) onto the dummy-frame
819 stack. */
b89667eb
DE
820 dummy_frame_push (caller_state, &dummy_id);
821
822 /* Discard both inf_status and caller_state cleanups.
823 From this point on we explicitly restore the associated state
824 or discard it. */
825 discard_cleanups (inf_status_cleanup);
96860204 826
7cd1089b 827 /* Register a clean-up for unwind_on_terminating_exception_breakpoint. */
aa7d318d
TT
828 terminate_bp_cleanup = make_cleanup (cleanup_delete_std_terminate_breakpoint,
829 NULL);
7cd1089b 830
96860204
AC
831 /* - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP -
832 If you're looking to implement asynchronous dummy-frames, then
833 just below is the place to chop this function in two.. */
834
b89667eb
DE
835 /* TP is invalid after run_inferior_call returns, so enclose this
836 in a block so that it's only in scope during the time it's valid. */
74cfe982 837 {
32400beb 838 struct thread_info *tp = inferior_thread ();
74cfe982 839
b89667eb
DE
840 /* Save this thread's ptid, we need it later but the thread
841 may have exited. */
842 call_thread_ptid = tp->ptid;
74cfe982 843
b89667eb 844 /* Run the inferior until it stops. */
f5871ec0 845
b89667eb 846 e = run_inferior_call (tp, real_pc);
52557533 847 }
04714b91 848
b89667eb
DE
849 /* Rethrow an error if we got one trying to run the inferior. */
850
851 if (e.reason < 0)
852 {
853 const char *name = get_function_name (funaddr,
854 name_buf, sizeof (name_buf));
855
16c381f0 856 discard_infcall_control_state (inf_status);
b89667eb
DE
857
858 /* We could discard the dummy frame here if the program exited,
859 but it will get garbage collected the next time the program is
860 run anyway. */
861
862 switch (e.reason)
863 {
864 case RETURN_ERROR:
ac74f770
MS
865 throw_error (e.error, _("%s\n\
866An error occurred while in a function called from GDB.\n\
867Evaluation of the expression containing the function\n\
868(%s) will be abandoned.\n\
869When the function is done executing, GDB will silently stop."),
b89667eb
DE
870 e.message, name);
871 case RETURN_QUIT:
872 default:
873 throw_exception (e);
874 }
875 }
876
877 /* If the program has exited, or we stopped at a different thread,
878 exit and inform the user. */
879
de04a248
DE
880 if (! target_has_execution)
881 {
b89667eb
DE
882 const char *name = get_function_name (funaddr,
883 name_buf, sizeof (name_buf));
884
885 /* If we try to restore the inferior status,
de04a248 886 we'll crash as the inferior is no longer running. */
16c381f0 887 discard_infcall_control_state (inf_status);
b89667eb
DE
888
889 /* We could discard the dummy frame here given that the program exited,
890 but it will get garbage collected the next time the program is
891 run anyway. */
892
3e43a32a
MS
893 error (_("The program being debugged exited while in a function "
894 "called from GDB.\n"
895 "Evaluation of the expression containing the function\n"
896 "(%s) will be abandoned."),
b89667eb
DE
897 name);
898 }
899
900 if (! ptid_equal (call_thread_ptid, inferior_ptid))
901 {
902 const char *name = get_function_name (funaddr,
903 name_buf, sizeof (name_buf));
904
905 /* We've switched threads. This can happen if another thread gets a
906 signal or breakpoint while our thread was running.
907 There's no point in restoring the inferior status,
908 we're in a different thread. */
16c381f0 909 discard_infcall_control_state (inf_status);
b89667eb
DE
910 /* Keep the dummy frame record, if the user switches back to the
911 thread with the hand-call, we'll need it. */
912 if (stopped_by_random_signal)
ac74f770
MS
913 error (_("\
914The program received a signal in another thread while\n\
915making a function call from GDB.\n\
916Evaluation of the expression containing the function\n\
917(%s) will be abandoned.\n\
918When the function is done executing, GDB will silently stop."),
b89667eb
DE
919 name);
920 else
ac74f770
MS
921 error (_("\
922The program stopped in another thread while making a function call from GDB.\n\
923Evaluation of the expression containing the function\n\
924(%s) will be abandoned.\n\
925When the function is done executing, GDB will silently stop."),
b89667eb 926 name);
de04a248
DE
927 }
928
aa7d318d 929 if (stopped_by_random_signal || stop_stack_dummy != STOP_STACK_DUMMY)
52557533 930 {
b89667eb
DE
931 const char *name = get_function_name (funaddr,
932 name_buf, sizeof (name_buf));
933
52557533
AC
934 if (stopped_by_random_signal)
935 {
936 /* We stopped inside the FUNCTION because of a random
937 signal. Further execution of the FUNCTION is not
1777feb0 938 allowed. */
04714b91 939
52557533
AC
940 if (unwind_on_signal_p)
941 {
1777feb0 942 /* The user wants the context restored. */
52557533
AC
943
944 /* We must get back to the frame we were before the
b89667eb
DE
945 dummy call. */
946 dummy_frame_pop (dummy_id);
947
948 /* We also need to restore inferior status to that before the
949 dummy call. */
16c381f0 950 restore_infcall_control_state (inf_status);
04714b91 951
52557533
AC
952 /* FIXME: Insert a bunch of wrap_here; name can be very
953 long if it's a C++ name with arguments and stuff. */
ac74f770
MS
954 error (_("\
955The program being debugged was signaled while in a function called from GDB.\n\
956GDB has restored the context to what it was before the call.\n\
957To change this behavior use \"set unwindonsignal off\".\n\
958Evaluation of the expression containing the function\n\
959(%s) will be abandoned."),
52557533
AC
960 name);
961 }
962 else
963 {
964 /* The user wants to stay in the frame where we stopped
b89667eb
DE
965 (default).
966 Discard inferior status, we're not at the same point
967 we started at. */
16c381f0 968 discard_infcall_control_state (inf_status);
b89667eb 969
52557533
AC
970 /* FIXME: Insert a bunch of wrap_here; name can be very
971 long if it's a C++ name with arguments and stuff. */
ac74f770
MS
972 error (_("\
973The program being debugged was signaled while in a function called from GDB.\n\
974GDB remains in the frame where the signal was received.\n\
975To change this behavior use \"set unwindonsignal on\".\n\
976Evaluation of the expression containing the function\n\
977(%s) will be abandoned.\n\
978When the function is done executing, GDB will silently stop."),
52557533
AC
979 name);
980 }
981 }
04714b91 982
aa7d318d 983 if (stop_stack_dummy == STOP_STD_TERMINATE)
52557533 984 {
aa7d318d
TT
985 /* We must get back to the frame we were before the dummy
986 call. */
987 dummy_frame_pop (dummy_id);
7cd1089b 988
aa7d318d
TT
989 /* We also need to restore inferior status to that before
990 the dummy call. */
16c381f0 991 restore_infcall_control_state (inf_status);
aa7d318d 992
ac74f770
MS
993 error (_("\
994The program being debugged entered a std::terminate call, most likely\n\
995caused by an unhandled C++ exception. GDB blocked this call in order\n\
996to prevent the program from being terminated, and has restored the\n\
997context to its original state before the call.\n\
998To change this behaviour use \"set unwind-on-terminating-exception off\".\n\
999Evaluation of the expression containing the function (%s)\n\
1000will be abandoned."),
aa7d318d
TT
1001 name);
1002 }
1003 else if (stop_stack_dummy == STOP_NONE)
1004 {
1005
b89667eb
DE
1006 /* We hit a breakpoint inside the FUNCTION.
1007 Keep the dummy frame, the user may want to examine its state.
1008 Discard inferior status, we're not at the same point
1009 we started at. */
16c381f0 1010 discard_infcall_control_state (inf_status);
b89667eb 1011
52557533
AC
1012 /* The following error message used to say "The expression
1013 which contained the function call has been discarded."
1014 It is a hard concept to explain in a few words. Ideally,
1015 GDB would be able to resume evaluation of the expression
1016 when the function finally is done executing. Perhaps
1017 someday this will be implemented (it would not be easy). */
1018 /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1019 a C++ name with arguments and stuff. */
ac74f770
MS
1020 error (_("\
1021The program being debugged stopped while in a function called from GDB.\n\
1022Evaluation of the expression containing the function\n\
1023(%s) will be abandoned.\n\
1024When the function is done executing, GDB will silently stop."),
b89667eb 1025 name);
52557533
AC
1026 }
1027
1028 /* The above code errors out, so ... */
e2e0b3e5 1029 internal_error (__FILE__, __LINE__, _("... should not be here"));
52557533 1030 }
04714b91 1031
aa7d318d 1032 do_cleanups (terminate_bp_cleanup);
2f2da8f6 1033
b89667eb
DE
1034 /* If we get here the called FUNCTION ran to completion,
1035 and the dummy frame has already been popped. */
74cfe982 1036
44e5158b 1037 {
d37346f0
DJ
1038 struct address_space *aspace = get_regcache_aspace (stop_registers);
1039 struct regcache *retbuf = regcache_xmalloc (gdbarch, aspace);
b89667eb 1040 struct cleanup *retbuf_cleanup = make_cleanup_regcache_xfree (retbuf);
1a4d7a36
MK
1041 struct value *retval = NULL;
1042
b89667eb
DE
1043 regcache_cpy_no_passthrough (retbuf, stop_registers);
1044
1045 /* Inferior call is successful. Restore the inferior status.
1046 At this stage, leave the RETBUF alone. */
16c381f0 1047 restore_infcall_control_state (inf_status);
b89667eb
DE
1048
1049 /* Figure out the value returned by the function. */
81b4675a 1050 retval = allocate_value (values_type);
b89667eb 1051
18648a37 1052 if (hidden_first_param_p)
81b4675a
UW
1053 read_value_memory (retval, 0, 1, struct_addr,
1054 value_contents_raw (retval),
1055 TYPE_LENGTH (values_type));
1056 else if (TYPE_CODE (target_values_type) != TYPE_CODE_VOID)
44e5158b 1057 {
1a4d7a36
MK
1058 /* If the function returns void, don't bother fetching the
1059 return value. */
6a3a010b
MR
1060 switch (gdbarch_return_value (gdbarch, function, target_values_type,
1061 NULL, NULL, NULL))
1a4d7a36
MK
1062 {
1063 case RETURN_VALUE_REGISTER_CONVENTION:
1064 case RETURN_VALUE_ABI_RETURNS_ADDRESS:
1065 case RETURN_VALUE_ABI_PRESERVES_ADDRESS:
6a3a010b 1066 gdbarch_return_value (gdbarch, function, values_type,
c055b101 1067 retbuf, value_contents_raw (retval), NULL);
1a4d7a36
MK
1068 break;
1069 case RETURN_VALUE_STRUCT_CONVENTION:
81b4675a
UW
1070 read_value_memory (retval, 0, 1, struct_addr,
1071 value_contents_raw (retval),
1072 TYPE_LENGTH (values_type));
1a4d7a36
MK
1073 break;
1074 }
1075 }
1076
44e5158b 1077 do_cleanups (retbuf_cleanup);
1a4d7a36 1078
b89667eb 1079 gdb_assert (retval);
44e5158b
AC
1080 return retval;
1081 }
04714b91 1082}
1a4d7a36 1083\f
04714b91 1084
1a4d7a36 1085/* Provide a prototype to silence -Wmissing-prototypes. */
04714b91
AC
1086void _initialize_infcall (void);
1087
1088void
1089_initialize_infcall (void)
1090{
1091 add_setshow_boolean_cmd ("coerce-float-to-double", class_obscure,
7915a72c
AC
1092 &coerce_float_to_double_p, _("\
1093Set coercion of floats to doubles when calling functions."), _("\
1094Show coercion of floats to doubles when calling functions"), _("\
04714b91
AC
1095Variables of type float should generally be converted to doubles before\n\
1096calling an unprototyped function, and left alone when calling a prototyped\n\
1097function. However, some older debug info formats do not provide enough\n\
1098information to determine that a function is prototyped. If this flag is\n\
1099set, GDB will perform the conversion for a function it considers\n\
1100unprototyped.\n\
7915a72c 1101The default is to perform the conversion.\n"),
2c5b56ce 1102 NULL,
920d2a44 1103 show_coerce_float_to_double_p,
2c5b56ce 1104 &setlist, &showlist);
04714b91
AC
1105
1106 add_setshow_boolean_cmd ("unwindonsignal", no_class,
7915a72c
AC
1107 &unwind_on_signal_p, _("\
1108Set unwinding of stack if a signal is received while in a call dummy."), _("\
1109Show unwinding of stack if a signal is received while in a call dummy."), _("\
04714b91
AC
1110The unwindonsignal lets the user determine what gdb should do if a signal\n\
1111is received while in a function called from gdb (call dummy). If set, gdb\n\
1112unwinds the stack and restore the context to what as it was before the call.\n\
7915a72c 1113The default is to stop in the frame where the signal was received."),
2c5b56ce 1114 NULL,
920d2a44 1115 show_unwind_on_signal_p,
2c5b56ce 1116 &setlist, &showlist);
7cd1089b
PM
1117
1118 add_setshow_boolean_cmd ("unwind-on-terminating-exception", no_class,
1119 &unwind_on_terminating_exception_p, _("\
1120Set unwinding of stack if std::terminate is called while in call dummy."), _("\
3e43a32a
MS
1121Show unwinding of stack if std::terminate() is called while in a call dummy."),
1122 _("\
7cd1089b
PM
1123The unwind on terminating exception flag lets the user determine\n\
1124what gdb should do if a std::terminate() call is made from the\n\
1125default exception handler. If set, gdb unwinds the stack and restores\n\
1126the context to what it was before the call. If unset, gdb allows the\n\
1127std::terminate call to proceed.\n\
1128The default is to unwind the frame."),
1129 NULL,
1130 show_unwind_on_terminating_exception_p,
1131 &setlist, &showlist);
1132
04714b91 1133}