Remove an unnecessary block in call_function_by_hand_dummy
[deliverable/binutils-gdb.git] / gdb / infcall.c
1 /* Perform an inferior function call, for GDB, the GNU debugger.
2
3 Copyright (C) 1986-2018 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 "infcall.h"
22 #include "breakpoint.h"
23 #include "tracepoint.h"
24 #include "target.h"
25 #include "regcache.h"
26 #include "inferior.h"
27 #include "infrun.h"
28 #include "block.h"
29 #include "gdbcore.h"
30 #include "language.h"
31 #include "objfiles.h"
32 #include "gdbcmd.h"
33 #include "command.h"
34 #include "dummy-frame.h"
35 #include "ada-lang.h"
36 #include "gdbthread.h"
37 #include "event-top.h"
38 #include "observable.h"
39 #include "top.h"
40 #include "interps.h"
41 #include "thread-fsm.h"
42 #include <algorithm>
43
44 /* If we can't find a function's name from its address,
45 we print this instead. */
46 #define RAW_FUNCTION_ADDRESS_FORMAT "at 0x%s"
47 #define RAW_FUNCTION_ADDRESS_SIZE (sizeof (RAW_FUNCTION_ADDRESS_FORMAT) \
48 + 2 * sizeof (CORE_ADDR))
49
50 /* NOTE: cagney/2003-04-16: What's the future of this code?
51
52 GDB needs an asynchronous expression evaluator, that means an
53 asynchronous inferior function call implementation, and that in
54 turn means restructuring the code so that it is event driven. */
55
56 /* How you should pass arguments to a function depends on whether it
57 was defined in K&R style or prototype style. If you define a
58 function using the K&R syntax that takes a `float' argument, then
59 callers must pass that argument as a `double'. If you define the
60 function using the prototype syntax, then you must pass the
61 argument as a `float', with no promotion.
62
63 Unfortunately, on certain older platforms, the debug info doesn't
64 indicate reliably how each function was defined. A function type's
65 TYPE_PROTOTYPED flag may be clear, even if the function was defined
66 in prototype style. When calling a function whose TYPE_PROTOTYPED
67 flag is clear, GDB consults this flag to decide what to do.
68
69 For modern targets, it is proper to assume that, if the prototype
70 flag is clear, that can be trusted: `float' arguments should be
71 promoted to `double'. For some older targets, if the prototype
72 flag is clear, that doesn't tell us anything. The default is to
73 trust the debug information; the user can override this behavior
74 with "set coerce-float-to-double 0". */
75
76 static int coerce_float_to_double_p = 1;
77 static void
78 show_coerce_float_to_double_p (struct ui_file *file, int from_tty,
79 struct cmd_list_element *c, const char *value)
80 {
81 fprintf_filtered (file,
82 _("Coercion of floats to doubles "
83 "when calling functions is %s.\n"),
84 value);
85 }
86
87 /* This boolean tells what gdb should do if a signal is received while
88 in a function called from gdb (call dummy). If set, gdb unwinds
89 the stack and restore the context to what as it was before the
90 call.
91
92 The default is to stop in the frame where the signal was received. */
93
94 static int unwind_on_signal_p = 0;
95 static void
96 show_unwind_on_signal_p (struct ui_file *file, int from_tty,
97 struct cmd_list_element *c, const char *value)
98 {
99 fprintf_filtered (file,
100 _("Unwinding of stack if a signal is "
101 "received while in a call dummy is %s.\n"),
102 value);
103 }
104
105 /* This boolean tells what gdb should do if a std::terminate call is
106 made while in a function called from gdb (call dummy).
107 As the confines of a single dummy stack prohibit out-of-frame
108 handlers from handling a raised exception, and as out-of-frame
109 handlers are common in C++, this can lead to no handler being found
110 by the unwinder, and a std::terminate call. This is a false positive.
111 If set, gdb unwinds the stack and restores the context to what it
112 was before the call.
113
114 The default is to unwind the frame if a std::terminate call is
115 made. */
116
117 static int unwind_on_terminating_exception_p = 1;
118
119 static void
120 show_unwind_on_terminating_exception_p (struct ui_file *file, int from_tty,
121 struct cmd_list_element *c,
122 const char *value)
123
124 {
125 fprintf_filtered (file,
126 _("Unwind stack if a C++ exception is "
127 "unhandled while in a call dummy is %s.\n"),
128 value);
129 }
130
131 /* Perform the standard coercions that are specified
132 for arguments to be passed to C or Ada functions.
133
134 If PARAM_TYPE is non-NULL, it is the expected parameter type.
135 IS_PROTOTYPED is non-zero if the function declaration is prototyped.
136 SP is the stack pointer were additional data can be pushed (updating
137 its value as needed). */
138
139 static struct value *
140 value_arg_coerce (struct gdbarch *gdbarch, struct value *arg,
141 struct type *param_type, int is_prototyped, CORE_ADDR *sp)
142 {
143 const struct builtin_type *builtin = builtin_type (gdbarch);
144 struct type *arg_type = check_typedef (value_type (arg));
145 struct type *type
146 = param_type ? check_typedef (param_type) : arg_type;
147
148 /* Perform any Ada-specific coercion first. */
149 if (current_language->la_language == language_ada)
150 arg = ada_convert_actual (arg, type);
151
152 /* Force the value to the target if we will need its address. At
153 this point, we could allocate arguments on the stack instead of
154 calling malloc if we knew that their addresses would not be
155 saved by the called function. */
156 arg = value_coerce_to_target (arg);
157
158 switch (TYPE_CODE (type))
159 {
160 case TYPE_CODE_REF:
161 case TYPE_CODE_RVALUE_REF:
162 {
163 struct value *new_value;
164
165 if (TYPE_IS_REFERENCE (arg_type))
166 return value_cast_pointers (type, arg, 0);
167
168 /* Cast the value to the reference's target type, and then
169 convert it back to a reference. This will issue an error
170 if the value was not previously in memory - in some cases
171 we should clearly be allowing this, but how? */
172 new_value = value_cast (TYPE_TARGET_TYPE (type), arg);
173 new_value = value_ref (new_value, TYPE_CODE (type));
174 return new_value;
175 }
176 case TYPE_CODE_INT:
177 case TYPE_CODE_CHAR:
178 case TYPE_CODE_BOOL:
179 case TYPE_CODE_ENUM:
180 /* If we don't have a prototype, coerce to integer type if necessary. */
181 if (!is_prototyped)
182 {
183 if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin->builtin_int))
184 type = builtin->builtin_int;
185 }
186 /* Currently all target ABIs require at least the width of an integer
187 type for an argument. We may have to conditionalize the following
188 type coercion for future targets. */
189 if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin->builtin_int))
190 type = builtin->builtin_int;
191 break;
192 case TYPE_CODE_FLT:
193 if (!is_prototyped && coerce_float_to_double_p)
194 {
195 if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin->builtin_double))
196 type = builtin->builtin_double;
197 else if (TYPE_LENGTH (type) > TYPE_LENGTH (builtin->builtin_double))
198 type = builtin->builtin_long_double;
199 }
200 break;
201 case TYPE_CODE_FUNC:
202 type = lookup_pointer_type (type);
203 break;
204 case TYPE_CODE_ARRAY:
205 /* Arrays are coerced to pointers to their first element, unless
206 they are vectors, in which case we want to leave them alone,
207 because they are passed by value. */
208 if (current_language->c_style_arrays)
209 if (!TYPE_VECTOR (type))
210 type = lookup_pointer_type (TYPE_TARGET_TYPE (type));
211 break;
212 case TYPE_CODE_UNDEF:
213 case TYPE_CODE_PTR:
214 case TYPE_CODE_STRUCT:
215 case TYPE_CODE_UNION:
216 case TYPE_CODE_VOID:
217 case TYPE_CODE_SET:
218 case TYPE_CODE_RANGE:
219 case TYPE_CODE_STRING:
220 case TYPE_CODE_ERROR:
221 case TYPE_CODE_MEMBERPTR:
222 case TYPE_CODE_METHODPTR:
223 case TYPE_CODE_METHOD:
224 case TYPE_CODE_COMPLEX:
225 default:
226 break;
227 }
228
229 return value_cast (type, arg);
230 }
231
232 /* See infcall.h. */
233
234 CORE_ADDR
235 find_function_addr (struct value *function,
236 struct type **retval_type,
237 struct type **function_type)
238 {
239 struct type *ftype = check_typedef (value_type (function));
240 struct gdbarch *gdbarch = get_type_arch (ftype);
241 struct type *value_type = NULL;
242 /* Initialize it just to avoid a GCC false warning. */
243 CORE_ADDR funaddr = 0;
244
245 /* If it's a member function, just look at the function
246 part of it. */
247
248 /* Determine address to call. */
249 if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
250 || TYPE_CODE (ftype) == TYPE_CODE_METHOD)
251 funaddr = value_address (function);
252 else if (TYPE_CODE (ftype) == TYPE_CODE_PTR)
253 {
254 funaddr = value_as_address (function);
255 ftype = check_typedef (TYPE_TARGET_TYPE (ftype));
256 if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
257 || TYPE_CODE (ftype) == TYPE_CODE_METHOD)
258 funaddr = gdbarch_convert_from_func_ptr_addr (gdbarch, funaddr,
259 current_top_target ());
260 }
261 if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
262 || TYPE_CODE (ftype) == TYPE_CODE_METHOD)
263 {
264 if (TYPE_GNU_IFUNC (ftype))
265 {
266 CORE_ADDR resolver_addr = funaddr;
267
268 /* Resolve the ifunc. Note this may call the resolver
269 function in the inferior. */
270 funaddr = gnu_ifunc_resolve_addr (gdbarch, resolver_addr);
271
272 /* Skip querying the function symbol if no RETVAL_TYPE or
273 FUNCTION_TYPE have been asked for. */
274 if (retval_type != NULL || function_type != NULL)
275 {
276 type *target_ftype = find_function_type (funaddr);
277 /* If we don't have debug info for the target function,
278 see if we can instead extract the target function's
279 type from the type that the resolver returns. */
280 if (target_ftype == NULL)
281 target_ftype = find_gnu_ifunc_target_type (resolver_addr);
282 if (target_ftype != NULL)
283 {
284 value_type = TYPE_TARGET_TYPE (check_typedef (target_ftype));
285 ftype = target_ftype;
286 }
287 }
288 }
289 else
290 value_type = TYPE_TARGET_TYPE (ftype);
291 }
292 else if (TYPE_CODE (ftype) == TYPE_CODE_INT)
293 {
294 /* Handle the case of functions lacking debugging info.
295 Their values are characters since their addresses are char. */
296 if (TYPE_LENGTH (ftype) == 1)
297 funaddr = value_as_address (value_addr (function));
298 else
299 {
300 /* Handle function descriptors lacking debug info. */
301 int found_descriptor = 0;
302
303 funaddr = 0; /* pacify "gcc -Werror" */
304 if (VALUE_LVAL (function) == lval_memory)
305 {
306 CORE_ADDR nfunaddr;
307
308 funaddr = value_as_address (value_addr (function));
309 nfunaddr = funaddr;
310 funaddr
311 = gdbarch_convert_from_func_ptr_addr (gdbarch, funaddr,
312 current_top_target ());
313 if (funaddr != nfunaddr)
314 found_descriptor = 1;
315 }
316 if (!found_descriptor)
317 /* Handle integer used as address of a function. */
318 funaddr = (CORE_ADDR) value_as_long (function);
319 }
320 }
321 else
322 error (_("Invalid data type for function to be called."));
323
324 if (retval_type != NULL)
325 *retval_type = value_type;
326 if (function_type != NULL)
327 *function_type = ftype;
328 return funaddr + gdbarch_deprecated_function_start_offset (gdbarch);
329 }
330
331 /* For CALL_DUMMY_ON_STACK, push a breakpoint sequence that the called
332 function returns to. */
333
334 static CORE_ADDR
335 push_dummy_code (struct gdbarch *gdbarch,
336 CORE_ADDR sp, CORE_ADDR funaddr,
337 struct value **args, int nargs,
338 struct type *value_type,
339 CORE_ADDR *real_pc, CORE_ADDR *bp_addr,
340 struct regcache *regcache)
341 {
342 gdb_assert (gdbarch_push_dummy_code_p (gdbarch));
343
344 return gdbarch_push_dummy_code (gdbarch, sp, funaddr,
345 args, nargs, value_type, real_pc, bp_addr,
346 regcache);
347 }
348
349 /* See infcall.h. */
350
351 void
352 error_call_unknown_return_type (const char *func_name)
353 {
354 if (func_name != NULL)
355 error (_("'%s' has unknown return type; "
356 "cast the call to its declared return type"),
357 func_name);
358 else
359 error (_("function has unknown return type; "
360 "cast the call to its declared return type"));
361 }
362
363 /* Fetch the name of the function at FUNADDR.
364 This is used in printing an error message for call_function_by_hand.
365 BUF is used to print FUNADDR in hex if the function name cannot be
366 determined. It must be large enough to hold formatted result of
367 RAW_FUNCTION_ADDRESS_FORMAT. */
368
369 static const char *
370 get_function_name (CORE_ADDR funaddr, char *buf, int buf_size)
371 {
372 {
373 struct symbol *symbol = find_pc_function (funaddr);
374
375 if (symbol)
376 return SYMBOL_PRINT_NAME (symbol);
377 }
378
379 {
380 /* Try the minimal symbols. */
381 struct bound_minimal_symbol msymbol = lookup_minimal_symbol_by_pc (funaddr);
382
383 if (msymbol.minsym)
384 return MSYMBOL_PRINT_NAME (msymbol.minsym);
385 }
386
387 {
388 std::string tmp = string_printf (_(RAW_FUNCTION_ADDRESS_FORMAT),
389 hex_string (funaddr));
390
391 gdb_assert (tmp.length () + 1 <= buf_size);
392 return strcpy (buf, tmp.c_str ());
393 }
394 }
395
396 /* All the meta data necessary to extract the call's return value. */
397
398 struct call_return_meta_info
399 {
400 /* The caller frame's architecture. */
401 struct gdbarch *gdbarch;
402
403 /* The called function. */
404 struct value *function;
405
406 /* The return value's type. */
407 struct type *value_type;
408
409 /* Are we returning a value using a structure return or a normal
410 value return? */
411 int struct_return_p;
412
413 /* If using a structure return, this is the structure's address. */
414 CORE_ADDR struct_addr;
415 };
416
417 /* Extract the called function's return value. */
418
419 static struct value *
420 get_call_return_value (struct call_return_meta_info *ri)
421 {
422 struct value *retval = NULL;
423 thread_info *thr = inferior_thread ();
424 bool stack_temporaries = thread_stack_temporaries_enabled_p (thr);
425
426 if (TYPE_CODE (ri->value_type) == TYPE_CODE_VOID)
427 retval = allocate_value (ri->value_type);
428 else if (ri->struct_return_p)
429 {
430 if (stack_temporaries)
431 {
432 retval = value_from_contents_and_address (ri->value_type, NULL,
433 ri->struct_addr);
434 push_thread_stack_temporary (thr, retval);
435 }
436 else
437 {
438 retval = allocate_value (ri->value_type);
439 read_value_memory (retval, 0, 1, ri->struct_addr,
440 value_contents_raw (retval),
441 TYPE_LENGTH (ri->value_type));
442 }
443 }
444 else
445 {
446 retval = allocate_value (ri->value_type);
447 gdbarch_return_value (ri->gdbarch, ri->function, ri->value_type,
448 get_current_regcache (),
449 value_contents_raw (retval), NULL);
450 if (stack_temporaries && class_or_union_p (ri->value_type))
451 {
452 /* Values of class type returned in registers are copied onto
453 the stack and their lval_type set to lval_memory. This is
454 required because further evaluation of the expression
455 could potentially invoke methods on the return value
456 requiring GDB to evaluate the "this" pointer. To evaluate
457 the this pointer, GDB needs the memory address of the
458 value. */
459 value_force_lval (retval, ri->struct_addr);
460 push_thread_stack_temporary (thr, retval);
461 }
462 }
463
464 gdb_assert (retval != NULL);
465 return retval;
466 }
467
468 /* Data for the FSM that manages an infcall. It's main job is to
469 record the called function's return value. */
470
471 struct call_thread_fsm
472 {
473 /* The base class. */
474 struct thread_fsm thread_fsm;
475
476 /* All the info necessary to be able to extract the return
477 value. */
478 struct call_return_meta_info return_meta_info;
479
480 /* The called function's return value. This is extracted from the
481 target before the dummy frame is popped. */
482 struct value *return_value;
483
484 /* The top level that started the infcall (and is synchronously
485 waiting for it to end). */
486 struct ui *waiting_ui;
487 };
488
489 static int call_thread_fsm_should_stop (struct thread_fsm *self,
490 struct thread_info *thread);
491 static int call_thread_fsm_should_notify_stop (struct thread_fsm *self);
492
493 /* call_thread_fsm's vtable. */
494
495 static struct thread_fsm_ops call_thread_fsm_ops =
496 {
497 NULL, /*dtor */
498 NULL, /* clean_up */
499 call_thread_fsm_should_stop,
500 NULL, /* return_value */
501 NULL, /* async_reply_reason*/
502 call_thread_fsm_should_notify_stop,
503 };
504
505 /* Allocate a new call_thread_fsm object. */
506
507 static struct call_thread_fsm *
508 new_call_thread_fsm (struct ui *waiting_ui, struct interp *cmd_interp,
509 struct gdbarch *gdbarch, struct value *function,
510 struct type *value_type,
511 int struct_return_p, CORE_ADDR struct_addr)
512 {
513 struct call_thread_fsm *sm;
514
515 sm = XCNEW (struct call_thread_fsm);
516 thread_fsm_ctor (&sm->thread_fsm, &call_thread_fsm_ops, cmd_interp);
517
518 sm->return_meta_info.gdbarch = gdbarch;
519 sm->return_meta_info.function = function;
520 sm->return_meta_info.value_type = value_type;
521 sm->return_meta_info.struct_return_p = struct_return_p;
522 sm->return_meta_info.struct_addr = struct_addr;
523
524 sm->waiting_ui = waiting_ui;
525
526 return sm;
527 }
528
529 /* Implementation of should_stop method for infcalls. */
530
531 static int
532 call_thread_fsm_should_stop (struct thread_fsm *self,
533 struct thread_info *thread)
534 {
535 struct call_thread_fsm *f = (struct call_thread_fsm *) self;
536
537 if (stop_stack_dummy == STOP_STACK_DUMMY)
538 {
539 /* Done. */
540 thread_fsm_set_finished (self);
541
542 /* Stash the return value before the dummy frame is popped and
543 registers are restored to what they were before the
544 call.. */
545 f->return_value = get_call_return_value (&f->return_meta_info);
546
547 /* Break out of wait_sync_command_done. */
548 scoped_restore save_ui = make_scoped_restore (&current_ui, f->waiting_ui);
549 target_terminal::ours ();
550 f->waiting_ui->prompt_state = PROMPT_NEEDED;
551 }
552
553 return 1;
554 }
555
556 /* Implementation of should_notify_stop method for infcalls. */
557
558 static int
559 call_thread_fsm_should_notify_stop (struct thread_fsm *self)
560 {
561 if (thread_fsm_finished_p (self))
562 {
563 /* Infcall succeeded. Be silent and proceed with evaluating the
564 expression. */
565 return 0;
566 }
567
568 /* Something wrong happened. E.g., an unexpected breakpoint
569 triggered, or a signal was intercepted. Notify the stop. */
570 return 1;
571 }
572
573 /* Subroutine of call_function_by_hand to simplify it.
574 Start up the inferior and wait for it to stop.
575 Return the exception if there's an error, or an exception with
576 reason >= 0 if there's no error.
577
578 This is done inside a TRY_CATCH so the caller needn't worry about
579 thrown errors. The caller should rethrow if there's an error. */
580
581 static struct gdb_exception
582 run_inferior_call (struct call_thread_fsm *sm,
583 struct thread_info *call_thread, CORE_ADDR real_pc)
584 {
585 struct gdb_exception caught_error = exception_none;
586 int saved_in_infcall = call_thread->control.in_infcall;
587 ptid_t call_thread_ptid = call_thread->ptid;
588 enum prompt_state saved_prompt_state = current_ui->prompt_state;
589 int was_running = call_thread->state == THREAD_RUNNING;
590 int saved_ui_async = current_ui->async;
591
592 /* Infcalls run synchronously, in the foreground. */
593 current_ui->prompt_state = PROMPT_BLOCKED;
594 /* So that we don't print the prompt prematurely in
595 fetch_inferior_event. */
596 current_ui->async = 0;
597
598 delete_file_handler (current_ui->input_fd);
599
600 call_thread->control.in_infcall = 1;
601
602 clear_proceed_status (0);
603
604 /* Associate the FSM with the thread after clear_proceed_status
605 (otherwise it'd clear this FSM), and before anything throws, so
606 we don't leak it (and any resources it manages). */
607 call_thread->thread_fsm = &sm->thread_fsm;
608
609 disable_watchpoints_before_interactive_call_start ();
610
611 /* We want to print return value, please... */
612 call_thread->control.proceed_to_finish = 1;
613
614 TRY
615 {
616 proceed (real_pc, GDB_SIGNAL_0);
617
618 /* Inferior function calls are always synchronous, even if the
619 target supports asynchronous execution. */
620 wait_sync_command_done ();
621 }
622 CATCH (e, RETURN_MASK_ALL)
623 {
624 caught_error = e;
625 }
626 END_CATCH
627
628 /* If GDB has the prompt blocked before, then ensure that it remains
629 so. normal_stop calls async_enable_stdin, so reset the prompt
630 state again here. In other cases, stdin will be re-enabled by
631 inferior_event_handler, when an exception is thrown. */
632 current_ui->prompt_state = saved_prompt_state;
633 if (current_ui->prompt_state == PROMPT_BLOCKED)
634 delete_file_handler (current_ui->input_fd);
635 else
636 ui_register_input_event_handler (current_ui);
637 current_ui->async = saved_ui_async;
638
639 /* If the infcall does NOT succeed, normal_stop will have already
640 finished the thread states. However, on success, normal_stop
641 defers here, so that we can set back the thread states to what
642 they were before the call. Note that we must also finish the
643 state of new threads that might have spawned while the call was
644 running. The main cases to handle are:
645
646 - "(gdb) print foo ()", or any other command that evaluates an
647 expression at the prompt. (The thread was marked stopped before.)
648
649 - "(gdb) break foo if return_false()" or similar cases where we
650 do an infcall while handling an event (while the thread is still
651 marked running). In this example, whether the condition
652 evaluates true and thus we'll present a user-visible stop is
653 decided elsewhere. */
654 if (!was_running
655 && call_thread_ptid == inferior_ptid
656 && stop_stack_dummy == STOP_STACK_DUMMY)
657 finish_thread_state (user_visible_resume_ptid (0));
658
659 enable_watchpoints_after_interactive_call_stop ();
660
661 /* Call breakpoint_auto_delete on the current contents of the bpstat
662 of inferior call thread.
663 If all error()s out of proceed ended up calling normal_stop
664 (and perhaps they should; it already does in the special case
665 of error out of resume()), then we wouldn't need this. */
666 if (caught_error.reason < 0)
667 {
668 if (call_thread->state != THREAD_EXITED)
669 breakpoint_auto_delete (call_thread->control.stop_bpstat);
670 }
671
672 call_thread->control.in_infcall = saved_in_infcall;
673
674 return caught_error;
675 }
676
677 /* A cleanup function that calls delete_std_terminate_breakpoint. */
678 static void
679 cleanup_delete_std_terminate_breakpoint (void *ignore)
680 {
681 delete_std_terminate_breakpoint ();
682 }
683
684 /* See infcall.h. */
685
686 struct value *
687 call_function_by_hand (struct value *function,
688 type *default_return_type,
689 int nargs, struct value **args)
690 {
691 return call_function_by_hand_dummy (function, default_return_type,
692 nargs, args, NULL, NULL);
693 }
694
695 /* All this stuff with a dummy frame may seem unnecessarily complicated
696 (why not just save registers in GDB?). The purpose of pushing a dummy
697 frame which looks just like a real frame is so that if you call a
698 function and then hit a breakpoint (get a signal, etc), "backtrace"
699 will look right. Whether the backtrace needs to actually show the
700 stack at the time the inferior function was called is debatable, but
701 it certainly needs to not display garbage. So if you are contemplating
702 making dummy frames be different from normal frames, consider that. */
703
704 /* Perform a function call in the inferior.
705 ARGS is a vector of values of arguments (NARGS of them).
706 FUNCTION is a value, the function to be called.
707 Returns a value representing what the function returned.
708 May fail to return, if a breakpoint or signal is hit
709 during the execution of the function.
710
711 ARGS is modified to contain coerced values. */
712
713 struct value *
714 call_function_by_hand_dummy (struct value *function,
715 type *default_return_type,
716 int nargs, struct value **args,
717 dummy_frame_dtor_ftype *dummy_dtor,
718 void *dummy_dtor_data)
719 {
720 CORE_ADDR sp;
721 struct type *target_values_type;
722 unsigned char struct_return = 0, hidden_first_param_p = 0;
723 CORE_ADDR struct_addr = 0;
724 struct infcall_control_state *inf_status;
725 struct cleanup *inf_status_cleanup;
726 struct infcall_suspend_state *caller_state;
727 CORE_ADDR real_pc;
728 CORE_ADDR bp_addr;
729 struct frame_id dummy_id;
730 struct frame_info *frame;
731 struct gdbarch *gdbarch;
732 struct cleanup *terminate_bp_cleanup;
733 ptid_t call_thread_ptid;
734 struct gdb_exception e;
735 char name_buf[RAW_FUNCTION_ADDRESS_SIZE];
736
737 if (!target_has_execution)
738 noprocess ();
739
740 if (get_traceframe_number () >= 0)
741 error (_("May not call functions while looking at trace frames."));
742
743 if (execution_direction == EXEC_REVERSE)
744 error (_("Cannot call functions in reverse mode."));
745
746 /* We're going to run the target, and inspect the thread's state
747 afterwards. Hold a strong reference so that the pointer remains
748 valid even if the thread exits. */
749 thread_info_ref call_thread
750 = thread_info_ref::new_reference (inferior_thread ());
751
752 bool stack_temporaries = thread_stack_temporaries_enabled_p (call_thread.get ());
753
754 frame = get_current_frame ();
755 gdbarch = get_frame_arch (frame);
756
757 if (!gdbarch_push_dummy_call_p (gdbarch))
758 error (_("This target does not support function calls."));
759
760 /* A cleanup for the inferior status.
761 This is only needed while we're preparing the inferior function call. */
762 inf_status = save_infcall_control_state ();
763 inf_status_cleanup
764 = make_cleanup_restore_infcall_control_state (inf_status);
765
766 /* Save the caller's registers and other state associated with the
767 inferior itself so that they can be restored once the
768 callee returns. To allow nested calls the registers are (further
769 down) pushed onto a dummy frame stack. Include a cleanup (which
770 is tossed once the regcache has been pushed). */
771 caller_state = save_infcall_suspend_state ();
772 make_cleanup_restore_infcall_suspend_state (caller_state);
773
774 /* Ensure that the initial SP is correctly aligned. */
775 {
776 CORE_ADDR old_sp = get_frame_sp (frame);
777
778 if (gdbarch_frame_align_p (gdbarch))
779 {
780 sp = gdbarch_frame_align (gdbarch, old_sp);
781 /* NOTE: cagney/2003-08-13: Skip the "red zone". For some
782 ABIs, a function can use memory beyond the inner most stack
783 address. AMD64 called that region the "red zone". Skip at
784 least the "red zone" size before allocating any space on
785 the stack. */
786 if (gdbarch_inner_than (gdbarch, 1, 2))
787 sp -= gdbarch_frame_red_zone_size (gdbarch);
788 else
789 sp += gdbarch_frame_red_zone_size (gdbarch);
790 /* Still aligned? */
791 gdb_assert (sp == gdbarch_frame_align (gdbarch, sp));
792 /* NOTE: cagney/2002-09-18:
793
794 On a RISC architecture, a void parameterless generic dummy
795 frame (i.e., no parameters, no result) typically does not
796 need to push anything the stack and hence can leave SP and
797 FP. Similarly, a frameless (possibly leaf) function does
798 not push anything on the stack and, hence, that too can
799 leave FP and SP unchanged. As a consequence, a sequence of
800 void parameterless generic dummy frame calls to frameless
801 functions will create a sequence of effectively identical
802 frames (SP, FP and TOS and PC the same). This, not
803 suprisingly, results in what appears to be a stack in an
804 infinite loop --- when GDB tries to find a generic dummy
805 frame on the internal dummy frame stack, it will always
806 find the first one.
807
808 To avoid this problem, the code below always grows the
809 stack. That way, two dummy frames can never be identical.
810 It does burn a few bytes of stack but that is a small price
811 to pay :-). */
812 if (sp == old_sp)
813 {
814 if (gdbarch_inner_than (gdbarch, 1, 2))
815 /* Stack grows down. */
816 sp = gdbarch_frame_align (gdbarch, old_sp - 1);
817 else
818 /* Stack grows up. */
819 sp = gdbarch_frame_align (gdbarch, old_sp + 1);
820 }
821 /* SP may have underflown address zero here from OLD_SP. Memory access
822 functions will probably fail in such case but that is a target's
823 problem. */
824 }
825 else
826 /* FIXME: cagney/2002-09-18: Hey, you loose!
827
828 Who knows how badly aligned the SP is!
829
830 If the generic dummy frame ends up empty (because nothing is
831 pushed) GDB won't be able to correctly perform back traces.
832 If a target is having trouble with backtraces, first thing to
833 do is add FRAME_ALIGN() to the architecture vector. If that
834 fails, try dummy_id().
835
836 If the ABI specifies a "Red Zone" (see the doco) the code
837 below will quietly trash it. */
838 sp = old_sp;
839
840 /* Skip over the stack temporaries that might have been generated during
841 the evaluation of an expression. */
842 if (stack_temporaries)
843 {
844 struct value *lastval;
845
846 lastval = get_last_thread_stack_temporary (call_thread.get ());
847 if (lastval != NULL)
848 {
849 CORE_ADDR lastval_addr = value_address (lastval);
850
851 if (gdbarch_inner_than (gdbarch, 1, 2))
852 {
853 gdb_assert (sp >= lastval_addr);
854 sp = lastval_addr;
855 }
856 else
857 {
858 gdb_assert (sp <= lastval_addr);
859 sp = lastval_addr + TYPE_LENGTH (value_type (lastval));
860 }
861
862 if (gdbarch_frame_align_p (gdbarch))
863 sp = gdbarch_frame_align (gdbarch, sp);
864 }
865 }
866 }
867
868 type *ftype;
869 type *values_type;
870 CORE_ADDR funaddr = find_function_addr (function, &values_type, &ftype);
871
872 if (values_type == NULL)
873 values_type = default_return_type;
874 if (values_type == NULL)
875 {
876 const char *name = get_function_name (funaddr,
877 name_buf, sizeof (name_buf));
878 error (_("'%s' has unknown return type; "
879 "cast the call to its declared return type"),
880 name);
881 }
882
883 values_type = check_typedef (values_type);
884
885 /* Are we returning a value using a structure return (passing a
886 hidden argument pointing to storage) or a normal value return?
887 There are two cases: language-mandated structure return and
888 target ABI structure return. The variable STRUCT_RETURN only
889 describes the latter. The language version is handled by passing
890 the return location as the first parameter to the function,
891 even preceding "this". This is different from the target
892 ABI version, which is target-specific; for instance, on ia64
893 the first argument is passed in out0 but the hidden structure
894 return pointer would normally be passed in r8. */
895
896 if (gdbarch_return_in_first_hidden_param_p (gdbarch, values_type))
897 {
898 hidden_first_param_p = 1;
899
900 /* Tell the target specific argument pushing routine not to
901 expect a value. */
902 target_values_type = builtin_type (gdbarch)->builtin_void;
903 }
904 else
905 {
906 struct_return = using_struct_return (gdbarch, function, values_type);
907 target_values_type = values_type;
908 }
909
910 gdb::observers::inferior_call_pre.notify (inferior_ptid, funaddr);
911
912 /* Determine the location of the breakpoint (and possibly other
913 stuff) that the called function will return to. The SPARC, for a
914 function returning a structure or union, needs to make space for
915 not just the breakpoint but also an extra word containing the
916 size (?) of the structure being passed. */
917
918 switch (gdbarch_call_dummy_location (gdbarch))
919 {
920 case ON_STACK:
921 {
922 const gdb_byte *bp_bytes;
923 CORE_ADDR bp_addr_as_address;
924 int bp_size;
925
926 /* Be careful BP_ADDR is in inferior PC encoding while
927 BP_ADDR_AS_ADDRESS is a plain memory address. */
928
929 sp = push_dummy_code (gdbarch, sp, funaddr, args, nargs,
930 target_values_type, &real_pc, &bp_addr,
931 get_current_regcache ());
932
933 /* Write a legitimate instruction at the point where the infcall
934 breakpoint is going to be inserted. While this instruction
935 is never going to be executed, a user investigating the
936 memory from GDB would see this instruction instead of random
937 uninitialized bytes. We chose the breakpoint instruction
938 as it may look as the most logical one to the user and also
939 valgrind 3.7.0 needs it for proper vgdb inferior calls.
940
941 If software breakpoints are unsupported for this target we
942 leave the user visible memory content uninitialized. */
943
944 bp_addr_as_address = bp_addr;
945 bp_bytes = gdbarch_breakpoint_from_pc (gdbarch, &bp_addr_as_address,
946 &bp_size);
947 if (bp_bytes != NULL)
948 write_memory (bp_addr_as_address, bp_bytes, bp_size);
949 }
950 break;
951 case AT_ENTRY_POINT:
952 {
953 CORE_ADDR dummy_addr;
954
955 real_pc = funaddr;
956 dummy_addr = entry_point_address ();
957
958 /* A call dummy always consists of just a single breakpoint, so
959 its address is the same as the address of the dummy.
960
961 The actual breakpoint is inserted separatly so there is no need to
962 write that out. */
963 bp_addr = dummy_addr;
964 break;
965 }
966 default:
967 internal_error (__FILE__, __LINE__, _("bad switch"));
968 }
969
970 if (nargs < TYPE_NFIELDS (ftype))
971 error (_("Too few arguments in function call."));
972
973 for (int i = nargs - 1; i >= 0; i--)
974 {
975 int prototyped;
976 struct type *param_type;
977
978 /* FIXME drow/2002-05-31: Should just always mark methods as
979 prototyped. Can we respect TYPE_VARARGS? Probably not. */
980 if (TYPE_CODE (ftype) == TYPE_CODE_METHOD)
981 prototyped = 1;
982 if (TYPE_TARGET_TYPE (ftype) == NULL && TYPE_NFIELDS (ftype) == 0
983 && default_return_type != NULL)
984 {
985 /* Calling a no-debug function with the return type
986 explicitly cast. Assume the function is prototyped,
987 with a prototype matching the types of the arguments.
988 E.g., with:
989 float mult (float v1, float v2) { return v1 * v2; }
990 This:
991 (gdb) p (float) mult (2.0f, 3.0f)
992 Is a simpler alternative to:
993 (gdb) p ((float (*) (float, float)) mult) (2.0f, 3.0f)
994 */
995 prototyped = 1;
996 }
997 else if (i < TYPE_NFIELDS (ftype))
998 prototyped = TYPE_PROTOTYPED (ftype);
999 else
1000 prototyped = 0;
1001
1002 if (i < TYPE_NFIELDS (ftype))
1003 param_type = TYPE_FIELD_TYPE (ftype, i);
1004 else
1005 param_type = NULL;
1006
1007 args[i] = value_arg_coerce (gdbarch, args[i],
1008 param_type, prototyped, &sp);
1009
1010 if (param_type != NULL && language_pass_by_reference (param_type))
1011 args[i] = value_addr (args[i]);
1012 }
1013
1014 /* Reserve space for the return structure to be written on the
1015 stack, if necessary. Make certain that the value is correctly
1016 aligned.
1017
1018 While evaluating expressions, we reserve space on the stack for
1019 return values of class type even if the language ABI and the target
1020 ABI do not require that the return value be passed as a hidden first
1021 argument. This is because we want to store the return value as an
1022 on-stack temporary while the expression is being evaluated. This
1023 enables us to have chained function calls in expressions.
1024
1025 Keeping the return values as on-stack temporaries while the expression
1026 is being evaluated is OK because the thread is stopped until the
1027 expression is completely evaluated. */
1028
1029 if (struct_return || hidden_first_param_p
1030 || (stack_temporaries && class_or_union_p (values_type)))
1031 {
1032 if (gdbarch_inner_than (gdbarch, 1, 2))
1033 {
1034 /* Stack grows downward. Align STRUCT_ADDR and SP after
1035 making space for the return value. */
1036 sp -= TYPE_LENGTH (values_type);
1037 if (gdbarch_frame_align_p (gdbarch))
1038 sp = gdbarch_frame_align (gdbarch, sp);
1039 struct_addr = sp;
1040 }
1041 else
1042 {
1043 /* Stack grows upward. Align the frame, allocate space, and
1044 then again, re-align the frame??? */
1045 if (gdbarch_frame_align_p (gdbarch))
1046 sp = gdbarch_frame_align (gdbarch, sp);
1047 struct_addr = sp;
1048 sp += TYPE_LENGTH (values_type);
1049 if (gdbarch_frame_align_p (gdbarch))
1050 sp = gdbarch_frame_align (gdbarch, sp);
1051 }
1052 }
1053
1054 std::vector<struct value *> new_args;
1055 if (hidden_first_param_p)
1056 {
1057 /* Add the new argument to the front of the argument list. */
1058 new_args.push_back
1059 (value_from_pointer (lookup_pointer_type (values_type), struct_addr));
1060 std::copy (&args[0], &args[nargs], std::back_inserter (new_args));
1061 args = new_args.data ();
1062 nargs++;
1063 }
1064
1065 /* Create the dummy stack frame. Pass in the call dummy address as,
1066 presumably, the ABI code knows where, in the call dummy, the
1067 return address should be pointed. */
1068 sp = gdbarch_push_dummy_call (gdbarch, function, get_current_regcache (),
1069 bp_addr, nargs, args,
1070 sp, struct_return, struct_addr);
1071
1072 /* Set up a frame ID for the dummy frame so we can pass it to
1073 set_momentary_breakpoint. We need to give the breakpoint a frame
1074 ID so that the breakpoint code can correctly re-identify the
1075 dummy breakpoint. */
1076 /* Sanity. The exact same SP value is returned by PUSH_DUMMY_CALL,
1077 saved as the dummy-frame TOS, and used by dummy_id to form
1078 the frame ID's stack address. */
1079 dummy_id = frame_id_build (sp, bp_addr);
1080
1081 /* Create a momentary breakpoint at the return address of the
1082 inferior. That way it breaks when it returns. */
1083
1084 {
1085 symtab_and_line sal;
1086 sal.pspace = current_program_space;
1087 sal.pc = bp_addr;
1088 sal.section = find_pc_overlay (sal.pc);
1089
1090 /* Sanity. The exact same SP value is returned by
1091 PUSH_DUMMY_CALL, saved as the dummy-frame TOS, and used by
1092 dummy_id to form the frame ID's stack address. */
1093 breakpoint *bpt
1094 = set_momentary_breakpoint (gdbarch, sal,
1095 dummy_id, bp_call_dummy).release ();
1096
1097 /* set_momentary_breakpoint invalidates FRAME. */
1098 frame = NULL;
1099
1100 bpt->disposition = disp_del;
1101 gdb_assert (bpt->related_breakpoint == bpt);
1102
1103 breakpoint *longjmp_b = set_longjmp_breakpoint_for_call_dummy ();
1104 if (longjmp_b)
1105 {
1106 /* Link BPT into the chain of LONGJMP_B. */
1107 bpt->related_breakpoint = longjmp_b;
1108 while (longjmp_b->related_breakpoint != bpt->related_breakpoint)
1109 longjmp_b = longjmp_b->related_breakpoint;
1110 longjmp_b->related_breakpoint = bpt;
1111 }
1112 }
1113
1114 /* Create a breakpoint in std::terminate.
1115 If a C++ exception is raised in the dummy-frame, and the
1116 exception handler is (normally, and expected to be) out-of-frame,
1117 the default C++ handler will (wrongly) be called in an inferior
1118 function call. This is wrong, as an exception can be normally
1119 and legally handled out-of-frame. The confines of the dummy frame
1120 prevent the unwinder from finding the correct handler (or any
1121 handler, unless it is in-frame). The default handler calls
1122 std::terminate. This will kill the inferior. Assert that
1123 terminate should never be called in an inferior function
1124 call. Place a momentary breakpoint in the std::terminate function
1125 and if triggered in the call, rewind. */
1126 if (unwind_on_terminating_exception_p)
1127 set_std_terminate_breakpoint ();
1128
1129 /* Discard both inf_status and caller_state cleanups.
1130 From this point on we explicitly restore the associated state
1131 or discard it. */
1132 discard_cleanups (inf_status_cleanup);
1133
1134 /* Everything's ready, push all the info needed to restore the
1135 caller (and identify the dummy-frame) onto the dummy-frame
1136 stack. */
1137 dummy_frame_push (caller_state, &dummy_id, call_thread.get ());
1138 if (dummy_dtor != NULL)
1139 register_dummy_frame_dtor (dummy_id, call_thread.get (),
1140 dummy_dtor, dummy_dtor_data);
1141
1142 /* Register a clean-up for unwind_on_terminating_exception_breakpoint. */
1143 terminate_bp_cleanup = make_cleanup (cleanup_delete_std_terminate_breakpoint,
1144 NULL);
1145
1146 /* - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP -
1147 If you're looking to implement asynchronous dummy-frames, then
1148 just below is the place to chop this function in two.. */
1149
1150 {
1151 struct thread_fsm *saved_sm;
1152 struct call_thread_fsm *sm;
1153
1154 /* Save the current FSM. We'll override it. */
1155 saved_sm = call_thread->thread_fsm;
1156 call_thread->thread_fsm = NULL;
1157
1158 /* Save this thread's ptid, we need it later but the thread
1159 may have exited. */
1160 call_thread_ptid = call_thread->ptid;
1161
1162 /* Run the inferior until it stops. */
1163
1164 /* Create the FSM used to manage the infcall. It tells infrun to
1165 not report the stop to the user, and captures the return value
1166 before the dummy frame is popped. run_inferior_call registers
1167 it with the thread ASAP. */
1168 sm = new_call_thread_fsm (current_ui, command_interp (),
1169 gdbarch, function,
1170 values_type,
1171 struct_return || hidden_first_param_p,
1172 struct_addr);
1173
1174 e = run_inferior_call (sm, call_thread.get (), real_pc);
1175
1176 gdb::observers::inferior_call_post.notify (call_thread_ptid, funaddr);
1177
1178 if (call_thread->state != THREAD_EXITED)
1179 {
1180 /* The FSM should still be the same. */
1181 gdb_assert (call_thread->thread_fsm == &sm->thread_fsm);
1182
1183 if (thread_fsm_finished_p (call_thread->thread_fsm))
1184 {
1185 struct value *retval;
1186
1187 /* The inferior call is successful. Pop the dummy frame,
1188 which runs its destructors and restores the inferior's
1189 suspend state, and restore the inferior control
1190 state. */
1191 dummy_frame_pop (dummy_id, call_thread.get ());
1192 restore_infcall_control_state (inf_status);
1193
1194 /* Get the return value. */
1195 retval = sm->return_value;
1196
1197 /* Clean up / destroy the call FSM, and restore the
1198 original one. */
1199 thread_fsm_clean_up (call_thread->thread_fsm, call_thread.get ());
1200 thread_fsm_delete (call_thread->thread_fsm);
1201 call_thread->thread_fsm = saved_sm;
1202
1203 maybe_remove_breakpoints ();
1204
1205 do_cleanups (terminate_bp_cleanup);
1206 gdb_assert (retval != NULL);
1207 return retval;
1208 }
1209
1210 /* Didn't complete. Restore previous state machine, and
1211 handle the error. */
1212 call_thread->thread_fsm = saved_sm;
1213 }
1214 }
1215
1216 /* Rethrow an error if we got one trying to run the inferior. */
1217
1218 if (e.reason < 0)
1219 {
1220 const char *name = get_function_name (funaddr,
1221 name_buf, sizeof (name_buf));
1222
1223 discard_infcall_control_state (inf_status);
1224
1225 /* We could discard the dummy frame here if the program exited,
1226 but it will get garbage collected the next time the program is
1227 run anyway. */
1228
1229 switch (e.reason)
1230 {
1231 case RETURN_ERROR:
1232 throw_error (e.error, _("%s\n\
1233 An error occurred while in a function called from GDB.\n\
1234 Evaluation of the expression containing the function\n\
1235 (%s) will be abandoned.\n\
1236 When the function is done executing, GDB will silently stop."),
1237 e.message, name);
1238 case RETURN_QUIT:
1239 default:
1240 throw_exception (e);
1241 }
1242 }
1243
1244 /* If the program has exited, or we stopped at a different thread,
1245 exit and inform the user. */
1246
1247 if (! target_has_execution)
1248 {
1249 const char *name = get_function_name (funaddr,
1250 name_buf, sizeof (name_buf));
1251
1252 /* If we try to restore the inferior status,
1253 we'll crash as the inferior is no longer running. */
1254 discard_infcall_control_state (inf_status);
1255
1256 /* We could discard the dummy frame here given that the program exited,
1257 but it will get garbage collected the next time the program is
1258 run anyway. */
1259
1260 error (_("The program being debugged exited while in a function "
1261 "called from GDB.\n"
1262 "Evaluation of the expression containing the function\n"
1263 "(%s) will be abandoned."),
1264 name);
1265 }
1266
1267 if (call_thread_ptid != inferior_ptid)
1268 {
1269 const char *name = get_function_name (funaddr,
1270 name_buf, sizeof (name_buf));
1271
1272 /* We've switched threads. This can happen if another thread gets a
1273 signal or breakpoint while our thread was running.
1274 There's no point in restoring the inferior status,
1275 we're in a different thread. */
1276 discard_infcall_control_state (inf_status);
1277 /* Keep the dummy frame record, if the user switches back to the
1278 thread with the hand-call, we'll need it. */
1279 if (stopped_by_random_signal)
1280 error (_("\
1281 The program received a signal in another thread while\n\
1282 making a function call from GDB.\n\
1283 Evaluation of the expression containing the function\n\
1284 (%s) will be abandoned.\n\
1285 When the function is done executing, GDB will silently stop."),
1286 name);
1287 else
1288 error (_("\
1289 The program stopped in another thread while making a function call from GDB.\n\
1290 Evaluation of the expression containing the function\n\
1291 (%s) will be abandoned.\n\
1292 When the function is done executing, GDB will silently stop."),
1293 name);
1294 }
1295
1296 {
1297 /* Make a copy as NAME may be in an objfile freed by dummy_frame_pop. */
1298 std::string name = get_function_name (funaddr, name_buf,
1299 sizeof (name_buf));
1300
1301 if (stopped_by_random_signal)
1302 {
1303 /* We stopped inside the FUNCTION because of a random
1304 signal. Further execution of the FUNCTION is not
1305 allowed. */
1306
1307 if (unwind_on_signal_p)
1308 {
1309 /* The user wants the context restored. */
1310
1311 /* We must get back to the frame we were before the
1312 dummy call. */
1313 dummy_frame_pop (dummy_id, call_thread.get ());
1314
1315 /* We also need to restore inferior status to that before the
1316 dummy call. */
1317 restore_infcall_control_state (inf_status);
1318
1319 /* FIXME: Insert a bunch of wrap_here; name can be very
1320 long if it's a C++ name with arguments and stuff. */
1321 error (_("\
1322 The program being debugged was signaled while in a function called from GDB.\n\
1323 GDB has restored the context to what it was before the call.\n\
1324 To change this behavior use \"set unwindonsignal off\".\n\
1325 Evaluation of the expression containing the function\n\
1326 (%s) will be abandoned."),
1327 name.c_str ());
1328 }
1329 else
1330 {
1331 /* The user wants to stay in the frame where we stopped
1332 (default).
1333 Discard inferior status, we're not at the same point
1334 we started at. */
1335 discard_infcall_control_state (inf_status);
1336
1337 /* FIXME: Insert a bunch of wrap_here; name can be very
1338 long if it's a C++ name with arguments and stuff. */
1339 error (_("\
1340 The program being debugged was signaled while in a function called from GDB.\n\
1341 GDB remains in the frame where the signal was received.\n\
1342 To change this behavior use \"set unwindonsignal on\".\n\
1343 Evaluation of the expression containing the function\n\
1344 (%s) will be abandoned.\n\
1345 When the function is done executing, GDB will silently stop."),
1346 name.c_str ());
1347 }
1348 }
1349
1350 if (stop_stack_dummy == STOP_STD_TERMINATE)
1351 {
1352 /* We must get back to the frame we were before the dummy
1353 call. */
1354 dummy_frame_pop (dummy_id, call_thread.get ());
1355
1356 /* We also need to restore inferior status to that before
1357 the dummy call. */
1358 restore_infcall_control_state (inf_status);
1359
1360 error (_("\
1361 The program being debugged entered a std::terminate call, most likely\n\
1362 caused by an unhandled C++ exception. GDB blocked this call in order\n\
1363 to prevent the program from being terminated, and has restored the\n\
1364 context to its original state before the call.\n\
1365 To change this behaviour use \"set unwind-on-terminating-exception off\".\n\
1366 Evaluation of the expression containing the function (%s)\n\
1367 will be abandoned."),
1368 name.c_str ());
1369 }
1370 else if (stop_stack_dummy == STOP_NONE)
1371 {
1372
1373 /* We hit a breakpoint inside the FUNCTION.
1374 Keep the dummy frame, the user may want to examine its state.
1375 Discard inferior status, we're not at the same point
1376 we started at. */
1377 discard_infcall_control_state (inf_status);
1378
1379 /* The following error message used to say "The expression
1380 which contained the function call has been discarded."
1381 It is a hard concept to explain in a few words. Ideally,
1382 GDB would be able to resume evaluation of the expression
1383 when the function finally is done executing. Perhaps
1384 someday this will be implemented (it would not be easy). */
1385 /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1386 a C++ name with arguments and stuff. */
1387 error (_("\
1388 The program being debugged stopped while in a function called from GDB.\n\
1389 Evaluation of the expression containing the function\n\
1390 (%s) will be abandoned.\n\
1391 When the function is done executing, GDB will silently stop."),
1392 name.c_str ());
1393 }
1394
1395 }
1396
1397 /* The above code errors out, so ... */
1398 gdb_assert_not_reached ("... should not be here");
1399 }
1400
1401 void
1402 _initialize_infcall (void)
1403 {
1404 add_setshow_boolean_cmd ("coerce-float-to-double", class_obscure,
1405 &coerce_float_to_double_p, _("\
1406 Set coercion of floats to doubles when calling functions."), _("\
1407 Show coercion of floats to doubles when calling functions"), _("\
1408 Variables of type float should generally be converted to doubles before\n\
1409 calling an unprototyped function, and left alone when calling a prototyped\n\
1410 function. However, some older debug info formats do not provide enough\n\
1411 information to determine that a function is prototyped. If this flag is\n\
1412 set, GDB will perform the conversion for a function it considers\n\
1413 unprototyped.\n\
1414 The default is to perform the conversion.\n"),
1415 NULL,
1416 show_coerce_float_to_double_p,
1417 &setlist, &showlist);
1418
1419 add_setshow_boolean_cmd ("unwindonsignal", no_class,
1420 &unwind_on_signal_p, _("\
1421 Set unwinding of stack if a signal is received while in a call dummy."), _("\
1422 Show unwinding of stack if a signal is received while in a call dummy."), _("\
1423 The unwindonsignal lets the user determine what gdb should do if a signal\n\
1424 is received while in a function called from gdb (call dummy). If set, gdb\n\
1425 unwinds the stack and restore the context to what as it was before the call.\n\
1426 The default is to stop in the frame where the signal was received."),
1427 NULL,
1428 show_unwind_on_signal_p,
1429 &setlist, &showlist);
1430
1431 add_setshow_boolean_cmd ("unwind-on-terminating-exception", no_class,
1432 &unwind_on_terminating_exception_p, _("\
1433 Set unwinding of stack if std::terminate is called while in call dummy."), _("\
1434 Show unwinding of stack if std::terminate() is called while in a call dummy."),
1435 _("\
1436 The unwind on terminating exception flag lets the user determine\n\
1437 what gdb should do if a std::terminate() call is made from the\n\
1438 default exception handler. If set, gdb unwinds the stack and restores\n\
1439 the context to what it was before the call. If unset, gdb allows the\n\
1440 std::terminate call to proceed.\n\
1441 The default is to unwind the frame."),
1442 NULL,
1443 show_unwind_on_terminating_exception_p,
1444 &setlist, &showlist);
1445
1446 }
This page took 0.061266 seconds and 5 git commands to generate.