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