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