GDB (xrefs)
/tmp/gdb-7.10/gdb/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-2015 Free Software Foundation, Inc.
4 
5  This file is part of GDB.
6 
7  This program is free software; you can redistribute it and/or modify
8  it under the terms of the GNU General Public License as published by
9  the Free Software Foundation; either version 3 of the License, or
10  (at your option) any later version.
11 
12  This program is distributed in the hope that it will be useful,
13  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  GNU General Public License for more details.
16 
17  You should have received a copy of the GNU General Public License
18  along with this program. If not, see <http://www.gnu.org/licenses/>. */
19 
20 #include "defs.h"
21 #include "breakpoint.h"
22 #include "tracepoint.h"
23 #include "target.h"
24 #include "regcache.h"
25 #include "inferior.h"
26 #include "infrun.h"
27 #include "block.h"
28 #include "gdbcore.h"
29 #include "language.h"
30 #include "objfiles.h"
31 #include "gdbcmd.h"
32 #include "command.h"
33 #include "infcall.h"
34 #include "dummy-frame.h"
35 #include "ada-lang.h"
36 #include "gdbthread.h"
37 #include "event-top.h"
38 #include "observer.h"
39 
40 /* If we can't find a function's name from its address,
41  we print this instead. */
42 #define RAW_FUNCTION_ADDRESS_FORMAT "at 0x%s"
43 #define RAW_FUNCTION_ADDRESS_SIZE (sizeof (RAW_FUNCTION_ADDRESS_FORMAT) \
44  + 2 * sizeof (CORE_ADDR))
45 
46 /* NOTE: cagney/2003-04-16: What's the future of this code?
47 
48  GDB needs an asynchronous expression evaluator, that means an
49  asynchronous inferior function call implementation, and that in
50  turn means restructuring the code so that it is event driven. */
51 
52 /* How you should pass arguments to a function depends on whether it
53  was defined in K&R style or prototype style. If you define a
54  function using the K&R syntax that takes a `float' argument, then
55  callers must pass that argument as a `double'. If you define the
56  function using the prototype syntax, then you must pass the
57  argument as a `float', with no promotion.
58 
59  Unfortunately, on certain older platforms, the debug info doesn't
60  indicate reliably how each function was defined. A function type's
61  TYPE_FLAG_PROTOTYPED flag may be clear, even if the function was
62  defined in prototype style. When calling a function whose
63  TYPE_FLAG_PROTOTYPED flag is clear, GDB consults this flag to
64  decide what to do.
65 
66  For modern targets, it is proper to assume that, if the prototype
67  flag is clear, that can be trusted: `float' arguments should be
68  promoted to `double'. For some older targets, if the prototype
69  flag is clear, that doesn't tell us anything. The default is to
70  trust the debug information; the user can override this behavior
71  with "set coerce-float-to-double 0". */
72 
73 static int coerce_float_to_double_p = 1;
74 static void
75 show_coerce_float_to_double_p (struct ui_file *file, int from_tty,
76  struct cmd_list_element *c, const char *value)
77 {
78  fprintf_filtered (file,
79  _("Coercion of floats to doubles "
80  "when calling functions is %s.\n"),
81  value);
82 }
83 
84 /* This boolean tells what gdb should do if a signal is received while
85  in a function called from gdb (call dummy). If set, gdb unwinds
86  the stack and restore the context to what as it was before the
87  call.
88 
89  The default is to stop in the frame where the signal was received. */
90 
91 static int unwind_on_signal_p = 0;
92 static void
93 show_unwind_on_signal_p (struct ui_file *file, int from_tty,
94  struct cmd_list_element *c, const char *value)
95 {
96  fprintf_filtered (file,
97  _("Unwinding of stack if a signal is "
98  "received while in a call dummy is %s.\n"),
99  value);
100 }
101 
102 /* This boolean tells what gdb should do if a std::terminate call is
103  made while in a function called from gdb (call dummy).
104  As the confines of a single dummy stack prohibit out-of-frame
105  handlers from handling a raised exception, and as out-of-frame
106  handlers are common in C++, this can lead to no handler being found
107  by the unwinder, and a std::terminate call. This is a false positive.
108  If set, gdb unwinds the stack and restores the context to what it
109  was before the call.
110 
111  The default is to unwind the frame if a std::terminate call is
112  made. */
113 
115 
116 static void
118  struct cmd_list_element *c,
119  const char *value)
120 
121 {
122  fprintf_filtered (file,
123  _("Unwind stack if a C++ exception is "
124  "unhandled while in a call dummy is %s.\n"),
125  value);
126 }
127 
128 /* Perform the standard coercions that are specified
129  for arguments to be passed to C or Ada functions.
130 
131  If PARAM_TYPE is non-NULL, it is the expected parameter type.
132  IS_PROTOTYPED is non-zero if the function declaration is prototyped.
133  SP is the stack pointer were additional data can be pushed (updating
134  its value as needed). */
135 
136 static struct value *
137 value_arg_coerce (struct gdbarch *gdbarch, struct value *arg,
138  struct type *param_type, int is_prototyped, CORE_ADDR *sp)
139 {
140  const struct builtin_type *builtin = builtin_type (gdbarch);
141  struct type *arg_type = check_typedef (value_type (arg));
142  struct type *type
143  = param_type ? check_typedef (param_type) : arg_type;
144 
145  /* Perform any Ada-specific coercion first. */
147  arg = ada_convert_actual (arg, type);
148 
149  /* Force the value to the target if we will need its address. At
150  this point, we could allocate arguments on the stack instead of
151  calling malloc if we knew that their addresses would not be
152  saved by the called function. */
153  arg = value_coerce_to_target (arg);
154 
155  switch (TYPE_CODE (type))
156  {
157  case TYPE_CODE_REF:
158  {
159  struct value *new_value;
160 
161  if (TYPE_CODE (arg_type) == TYPE_CODE_REF)
162  return value_cast_pointers (type, arg, 0);
163 
164  /* Cast the value to the reference's target type, and then
165  convert it back to a reference. This will issue an error
166  if the value was not previously in memory - in some cases
167  we should clearly be allowing this, but how? */
168  new_value = value_cast (TYPE_TARGET_TYPE (type), arg);
169  new_value = value_ref (new_value);
170  return new_value;
171  }
172  case TYPE_CODE_INT:
173  case TYPE_CODE_CHAR:
174  case TYPE_CODE_BOOL:
175  case TYPE_CODE_ENUM:
176  /* If we don't have a prototype, coerce to integer type if necessary. */
177  if (!is_prototyped)
178  {
179  if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin->builtin_int))
180  type = builtin->builtin_int;
181  }
182  /* Currently all target ABIs require at least the width of an integer
183  type for an argument. We may have to conditionalize the following
184  type coercion for future targets. */
185  if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin->builtin_int))
186  type = builtin->builtin_int;
187  break;
188  case TYPE_CODE_FLT:
189  if (!is_prototyped && coerce_float_to_double_p)
190  {
191  if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin->builtin_double))
192  type = builtin->builtin_double;
193  else if (TYPE_LENGTH (type) > TYPE_LENGTH (builtin->builtin_double))
194  type = builtin->builtin_long_double;
195  }
196  break;
197  case TYPE_CODE_FUNC:
198  type = lookup_pointer_type (type);
199  break;
200  case TYPE_CODE_ARRAY:
201  /* Arrays are coerced to pointers to their first element, unless
202  they are vectors, in which case we want to leave them alone,
203  because they are passed by value. */
205  if (!TYPE_VECTOR (type))
206  type = lookup_pointer_type (TYPE_TARGET_TYPE (type));
207  break;
208  case TYPE_CODE_UNDEF:
209  case TYPE_CODE_PTR:
210  case TYPE_CODE_STRUCT:
211  case TYPE_CODE_UNION:
212  case TYPE_CODE_VOID:
213  case TYPE_CODE_SET:
214  case TYPE_CODE_RANGE:
215  case TYPE_CODE_STRING:
216  case TYPE_CODE_ERROR:
217  case TYPE_CODE_MEMBERPTR:
218  case TYPE_CODE_METHODPTR:
219  case TYPE_CODE_METHOD:
220  case TYPE_CODE_COMPLEX:
221  default:
222  break;
223  }
224 
225  return value_cast (type, arg);
226 }
227 
228 /* Return the return type of a function with its first instruction exactly at
229  the PC address. Return NULL otherwise. */
230 
231 static struct type *
233 {
234  struct symbol *sym = find_pc_function (pc);
235 
236  if (sym != NULL && BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) == pc
237  && SYMBOL_TYPE (sym) != NULL)
238  return TYPE_TARGET_TYPE (SYMBOL_TYPE (sym));
239 
240  return NULL;
241 }
242 
243 /* Determine a function's address and its return type from its value.
244  Calls error() if the function is not valid for calling. */
245 
246 CORE_ADDR
247 find_function_addr (struct value *function, struct type **retval_type)
248 {
249  struct type *ftype = check_typedef (value_type (function));
250  struct gdbarch *gdbarch = get_type_arch (ftype);
251  struct type *value_type = NULL;
252  /* Initialize it just to avoid a GCC false warning. */
253  CORE_ADDR funaddr = 0;
254 
255  /* If it's a member function, just look at the function
256  part of it. */
257 
258  /* Determine address to call. */
259  if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
260  || TYPE_CODE (ftype) == TYPE_CODE_METHOD)
261  funaddr = value_address (function);
262  else if (TYPE_CODE (ftype) == TYPE_CODE_PTR)
263  {
264  funaddr = value_as_address (function);
265  ftype = check_typedef (TYPE_TARGET_TYPE (ftype));
266  if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
267  || TYPE_CODE (ftype) == TYPE_CODE_METHOD)
268  funaddr = gdbarch_convert_from_func_ptr_addr (gdbarch, funaddr,
269  &current_target);
270  }
271  if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
272  || TYPE_CODE (ftype) == TYPE_CODE_METHOD)
273  {
274  value_type = TYPE_TARGET_TYPE (ftype);
275 
276  if (TYPE_GNU_IFUNC (ftype))
277  {
278  funaddr = gnu_ifunc_resolve_addr (gdbarch, funaddr);
279 
280  /* Skip querying the function symbol if no RETVAL_TYPE has been
281  asked for. */
282  if (retval_type)
283  value_type = find_function_return_type (funaddr);
284  }
285  }
286  else if (TYPE_CODE (ftype) == TYPE_CODE_INT)
287  {
288  /* Handle the case of functions lacking debugging info.
289  Their values are characters since their addresses are char. */
290  if (TYPE_LENGTH (ftype) == 1)
291  funaddr = value_as_address (value_addr (function));
292  else
293  {
294  /* Handle function descriptors lacking debug info. */
295  int found_descriptor = 0;
296 
297  funaddr = 0; /* pacify "gcc -Werror" */
298  if (VALUE_LVAL (function) == lval_memory)
299  {
300  CORE_ADDR nfunaddr;
301 
302  funaddr = value_as_address (value_addr (function));
303  nfunaddr = funaddr;
304  funaddr = gdbarch_convert_from_func_ptr_addr (gdbarch, funaddr,
305  &current_target);
306  if (funaddr != nfunaddr)
307  found_descriptor = 1;
308  }
309  if (!found_descriptor)
310  /* Handle integer used as address of a function. */
311  funaddr = (CORE_ADDR) value_as_long (function);
312  }
313  }
314  else
315  error (_("Invalid data type for function to be called."));
316 
317  if (retval_type != NULL)
318  *retval_type = value_type;
319  return funaddr + gdbarch_deprecated_function_start_offset (gdbarch);
320 }
321 
322 /* For CALL_DUMMY_ON_STACK, push a breakpoint sequence that the called
323  function returns to. */
324 
325 static CORE_ADDR
327  CORE_ADDR sp, CORE_ADDR funaddr,
328  struct value **args, int nargs,
329  struct type *value_type,
330  CORE_ADDR *real_pc, CORE_ADDR *bp_addr,
331  struct regcache *regcache)
332 {
334 
335  return gdbarch_push_dummy_code (gdbarch, sp, funaddr,
336  args, nargs, value_type, real_pc, bp_addr,
337  regcache);
338 }
339 
340 /* Fetch the name of the function at FUNADDR.
341  This is used in printing an error message for call_function_by_hand.
342  BUF is used to print FUNADDR in hex if the function name cannot be
343  determined. It must be large enough to hold formatted result of
344  RAW_FUNCTION_ADDRESS_FORMAT. */
345 
346 static const char *
347 get_function_name (CORE_ADDR funaddr, char *buf, int buf_size)
348 {
349  {
350  struct symbol *symbol = find_pc_function (funaddr);
351 
352  if (symbol)
353  return SYMBOL_PRINT_NAME (symbol);
354  }
355 
356  {
357  /* Try the minimal symbols. */
358  struct bound_minimal_symbol msymbol = lookup_minimal_symbol_by_pc (funaddr);
359 
360  if (msymbol.minsym)
361  return MSYMBOL_PRINT_NAME (msymbol.minsym);
362  }
363 
364  {
366  hex_string (funaddr));
367 
368  gdb_assert (strlen (tmp) + 1 <= buf_size);
369  strcpy (buf, tmp);
370  xfree (tmp);
371  return buf;
372  }
373 }
374 
375 /* Subroutine of call_function_by_hand to simplify it.
376  Start up the inferior and wait for it to stop.
377  Return the exception if there's an error, or an exception with
378  reason >= 0 if there's no error.
379 
380  This is done inside a TRY_CATCH so the caller needn't worry about
381  thrown errors. The caller should rethrow if there's an error. */
382 
383 static struct gdb_exception
384 run_inferior_call (struct thread_info *call_thread, CORE_ADDR real_pc)
385 {
386  struct gdb_exception caught_error = exception_none;
387  int saved_in_infcall = call_thread->control.in_infcall;
388  ptid_t call_thread_ptid = call_thread->ptid;
389  int saved_sync_execution = sync_execution;
390  int was_running = call_thread->state == THREAD_RUNNING;
391 
392  /* Infcalls run synchronously, in the foreground. */
393  if (target_can_async_p ())
394  sync_execution = 1;
395 
396  call_thread->control.in_infcall = 1;
397 
399 
401 
402  /* We want to print return value, please... */
403  call_thread->control.proceed_to_finish = 1;
404 
405  TRY
406  {
407  int was_sync = sync_execution;
408 
409  proceed (real_pc, GDB_SIGNAL_0);
410 
411  /* Inferior function calls are always synchronous, even if the
412  target supports asynchronous execution. Do here what
413  `proceed' itself does in sync mode. */
414  if (target_can_async_p ())
415  {
417  normal_stop ();
418  /* If GDB was previously in sync execution mode, then ensure
419  that it remains so. normal_stop calls
420  async_enable_stdin, so reset it again here. In other
421  cases, stdin will be re-enabled by
422  inferior_event_handler, when an exception is thrown. */
423  if (was_sync)
425  }
426  }
428  {
429  caught_error = e;
430  }
431  END_CATCH
432 
433  /* At this point the current thread may have changed. Refresh
434  CALL_THREAD as it could be invalid if its thread has exited. */
435  call_thread = find_thread_ptid (call_thread_ptid);
436 
437  /* If the infcall does NOT succeed, normal_stop will have already
438  finished the thread states. However, on success, normal_stop
439  defers here, so that we can set back the thread states to what
440  they were before the call. Note that we must also finish the
441  state of new threads that might have spawned while the call was
442  running. The main cases to handle are:
443 
444  - "(gdb) print foo ()", or any other command that evaluates an
445  expression at the prompt. (The thread was marked stopped before.)
446 
447  - "(gdb) break foo if return_false()" or similar cases where we
448  do an infcall while handling an event (while the thread is still
449  marked running). In this example, whether the condition
450  evaluates true and thus we'll present a user-visible stop is
451  decided elsewhere. */
452  if (!was_running
453  && ptid_equal (call_thread_ptid, inferior_ptid)
456 
458 
459  /* Call breakpoint_auto_delete on the current contents of the bpstat
460  of inferior call thread.
461  If all error()s out of proceed ended up calling normal_stop
462  (and perhaps they should; it already does in the special case
463  of error out of resume()), then we wouldn't need this. */
464  if (caught_error.reason < 0)
465  {
466  if (call_thread != NULL)
467  breakpoint_auto_delete (call_thread->control.stop_bpstat);
468  }
469 
470  if (call_thread != NULL)
471  call_thread->control.in_infcall = saved_in_infcall;
472 
473  sync_execution = saved_sync_execution;
474 
475  return caught_error;
476 }
477 
478 /* A cleanup function that calls delete_std_terminate_breakpoint. */
479 static void
481 {
483 }
484 
485 /* See infcall.h. */
486 
487 struct value *
488 call_function_by_hand (struct value *function, int nargs, struct value **args)
489 {
490  return call_function_by_hand_dummy (function, nargs, args, NULL, NULL);
491 }
492 
493 /* Data for dummy_frame_context_saver. Structure can be freed only
494  after both dummy_frame_context_saver_dtor and
495  dummy_frame_context_saver_drop have been called for it. */
496 
498 {
499  /* Inferior registers fetched before associated dummy_frame got freed
500  and before any other destructors of associated dummy_frame got called.
501  It is initialized to NULL. */
502  struct regcache *retbuf;
503 
504  /* It is 1 if this dummy_frame_context_saver_drop has been already
505  called. */
507 };
508 
509 /* Free struct dummy_frame_context_saver. */
510 
511 static void
513 {
514  regcache_xfree (saver->retbuf);
515  xfree (saver);
516 }
517 
518 /* Destructor for associated dummy_frame. */
519 
520 static void
521 dummy_frame_context_saver_dtor (void *data_voidp, int registers_valid)
522 {
523  struct dummy_frame_context_saver *data = data_voidp;
524 
525  gdb_assert (data->retbuf == NULL);
526 
527  if (data->drop_done)
529  else if (registers_valid)
531 }
532 
533 /* Caller is no longer interested in this
534  struct dummy_frame_context_saver. After its associated dummy_frame
535  gets freed struct dummy_frame_context_saver can be also freed. */
536 
537 void
539 {
540  saver->drop_done = 1;
541 
544 }
545 
546 /* Stub dummy_frame_context_saver_drop compatible with make_cleanup. */
547 
548 void
550 {
551  struct dummy_frame_context_saver *saver = data;
552 
554 }
555 
556 /* Fetch RETBUF field of possibly opaque DTOR_DATA.
557  RETBUF must not be NULL. */
558 
559 struct regcache *
561 {
562  gdb_assert (saver->retbuf != NULL);
563  return saver->retbuf;
564 }
565 
566 /* Register provider of inferior registers at the time DUMMY_ID frame of
567  PTID gets freed (before inferior registers get restored to those
568  before dummy_frame). */
569 
572 {
573  struct dummy_frame_context_saver *saver;
574 
575  saver = xmalloc (sizeof (*saver));
576  saver->retbuf = NULL;
577  saver->drop_done = 0;
580  return saver;
581 }
582 
583 /* All this stuff with a dummy frame may seem unnecessarily complicated
584  (why not just save registers in GDB?). The purpose of pushing a dummy
585  frame which looks just like a real frame is so that if you call a
586  function and then hit a breakpoint (get a signal, etc), "backtrace"
587  will look right. Whether the backtrace needs to actually show the
588  stack at the time the inferior function was called is debatable, but
589  it certainly needs to not display garbage. So if you are contemplating
590  making dummy frames be different from normal frames, consider that. */
591 
592 /* Perform a function call in the inferior.
593  ARGS is a vector of values of arguments (NARGS of them).
594  FUNCTION is a value, the function to be called.
595  Returns a value representing what the function returned.
596  May fail to return, if a breakpoint or signal is hit
597  during the execution of the function.
598 
599  ARGS is modified to contain coerced values. */
600 
601 struct value *
603  int nargs, struct value **args,
604  dummy_frame_dtor_ftype *dummy_dtor,
605  void *dummy_dtor_data)
606 {
607  CORE_ADDR sp;
608  struct type *values_type, *target_values_type;
609  unsigned char struct_return = 0, hidden_first_param_p = 0;
610  CORE_ADDR struct_addr = 0;
611  struct infcall_control_state *inf_status;
612  struct cleanup *inf_status_cleanup;
613  struct infcall_suspend_state *caller_state;
614  CORE_ADDR funaddr;
615  CORE_ADDR real_pc;
616  struct type *ftype = check_typedef (value_type (function));
617  CORE_ADDR bp_addr;
618  struct frame_id dummy_id;
619  struct cleanup *args_cleanup;
620  struct frame_info *frame;
621  struct gdbarch *gdbarch;
622  struct cleanup *terminate_bp_cleanup;
623  ptid_t call_thread_ptid;
624  struct gdb_exception e;
625  char name_buf[RAW_FUNCTION_ADDRESS_SIZE];
626  int stack_temporaries = thread_stack_temporaries_enabled_p (inferior_ptid);
627  struct dummy_frame_context_saver *context_saver;
628  struct cleanup *context_saver_cleanup;
629 
630  if (TYPE_CODE (ftype) == TYPE_CODE_PTR)
631  ftype = check_typedef (TYPE_TARGET_TYPE (ftype));
632 
634  noprocess ();
635 
636  if (get_traceframe_number () >= 0)
637  error (_("May not call functions while looking at trace frames."));
638 
640  error (_("Cannot call functions in reverse mode."));
641 
642  frame = get_current_frame ();
643  gdbarch = get_frame_arch (frame);
644 
645  if (!gdbarch_push_dummy_call_p (gdbarch))
646  error (_("This target does not support function calls."));
647 
648  /* A cleanup for the inferior status.
649  This is only needed while we're preparing the inferior function call. */
650  inf_status = save_infcall_control_state ();
651  inf_status_cleanup
653 
654  /* Save the caller's registers and other state associated with the
655  inferior itself so that they can be restored once the
656  callee returns. To allow nested calls the registers are (further
657  down) pushed onto a dummy frame stack. Include a cleanup (which
658  is tossed once the regcache has been pushed). */
659  caller_state = save_infcall_suspend_state ();
661 
662  /* Ensure that the initial SP is correctly aligned. */
663  {
664  CORE_ADDR old_sp = get_frame_sp (frame);
665 
666  if (gdbarch_frame_align_p (gdbarch))
667  {
668  sp = gdbarch_frame_align (gdbarch, old_sp);
669  /* NOTE: cagney/2003-08-13: Skip the "red zone". For some
670  ABIs, a function can use memory beyond the inner most stack
671  address. AMD64 called that region the "red zone". Skip at
672  least the "red zone" size before allocating any space on
673  the stack. */
674  if (gdbarch_inner_than (gdbarch, 1, 2))
675  sp -= gdbarch_frame_red_zone_size (gdbarch);
676  else
677  sp += gdbarch_frame_red_zone_size (gdbarch);
678  /* Still aligned? */
679  gdb_assert (sp == gdbarch_frame_align (gdbarch, sp));
680  /* NOTE: cagney/2002-09-18:
681 
682  On a RISC architecture, a void parameterless generic dummy
683  frame (i.e., no parameters, no result) typically does not
684  need to push anything the stack and hence can leave SP and
685  FP. Similarly, a frameless (possibly leaf) function does
686  not push anything on the stack and, hence, that too can
687  leave FP and SP unchanged. As a consequence, a sequence of
688  void parameterless generic dummy frame calls to frameless
689  functions will create a sequence of effectively identical
690  frames (SP, FP and TOS and PC the same). This, not
691  suprisingly, results in what appears to be a stack in an
692  infinite loop --- when GDB tries to find a generic dummy
693  frame on the internal dummy frame stack, it will always
694  find the first one.
695 
696  To avoid this problem, the code below always grows the
697  stack. That way, two dummy frames can never be identical.
698  It does burn a few bytes of stack but that is a small price
699  to pay :-). */
700  if (sp == old_sp)
701  {
702  if (gdbarch_inner_than (gdbarch, 1, 2))
703  /* Stack grows down. */
704  sp = gdbarch_frame_align (gdbarch, old_sp - 1);
705  else
706  /* Stack grows up. */
707  sp = gdbarch_frame_align (gdbarch, old_sp + 1);
708  }
709  /* SP may have underflown address zero here from OLD_SP. Memory access
710  functions will probably fail in such case but that is a target's
711  problem. */
712  }
713  else
714  /* FIXME: cagney/2002-09-18: Hey, you loose!
715 
716  Who knows how badly aligned the SP is!
717 
718  If the generic dummy frame ends up empty (because nothing is
719  pushed) GDB won't be able to correctly perform back traces.
720  If a target is having trouble with backtraces, first thing to
721  do is add FRAME_ALIGN() to the architecture vector. If that
722  fails, try dummy_id().
723 
724  If the ABI specifies a "Red Zone" (see the doco) the code
725  below will quietly trash it. */
726  sp = old_sp;
727 
728  /* Skip over the stack temporaries that might have been generated during
729  the evaluation of an expression. */
730  if (stack_temporaries)
731  {
732  struct value *lastval;
733 
735  if (lastval != NULL)
736  {
737  CORE_ADDR lastval_addr = value_address (lastval);
738 
739  if (gdbarch_inner_than (gdbarch, 1, 2))
740  {
741  gdb_assert (sp >= lastval_addr);
742  sp = lastval_addr;
743  }
744  else
745  {
746  gdb_assert (sp <= lastval_addr);
747  sp = lastval_addr + TYPE_LENGTH (value_type (lastval));
748  }
749 
750  if (gdbarch_frame_align_p (gdbarch))
751  sp = gdbarch_frame_align (gdbarch, sp);
752  }
753  }
754  }
755 
756  funaddr = find_function_addr (function, &values_type);
757  if (!values_type)
758  values_type = builtin_type (gdbarch)->builtin_int;
759 
760  CHECK_TYPEDEF (values_type);
761 
762  /* Are we returning a value using a structure return (passing a
763  hidden argument pointing to storage) or a normal value return?
764  There are two cases: language-mandated structure return and
765  target ABI structure return. The variable STRUCT_RETURN only
766  describes the latter. The language version is handled by passing
767  the return location as the first parameter to the function,
768  even preceding "this". This is different from the target
769  ABI version, which is target-specific; for instance, on ia64
770  the first argument is passed in out0 but the hidden structure
771  return pointer would normally be passed in r8. */
772 
773  if (gdbarch_return_in_first_hidden_param_p (gdbarch, values_type))
774  {
775  hidden_first_param_p = 1;
776 
777  /* Tell the target specific argument pushing routine not to
778  expect a value. */
779  target_values_type = builtin_type (gdbarch)->builtin_void;
780  }
781  else
782  {
783  struct_return = using_struct_return (gdbarch, function, values_type);
784  target_values_type = values_type;
785  }
786 
788 
789  /* Determine the location of the breakpoint (and possibly other
790  stuff) that the called function will return to. The SPARC, for a
791  function returning a structure or union, needs to make space for
792  not just the breakpoint but also an extra word containing the
793  size (?) of the structure being passed. */
794 
795  switch (gdbarch_call_dummy_location (gdbarch))
796  {
797  case ON_STACK:
798  {
799  const gdb_byte *bp_bytes;
800  CORE_ADDR bp_addr_as_address;
801  int bp_size;
802 
803  /* Be careful BP_ADDR is in inferior PC encoding while
804  BP_ADDR_AS_ADDRESS is a plain memory address. */
805 
806  sp = push_dummy_code (gdbarch, sp, funaddr, args, nargs,
807  target_values_type, &real_pc, &bp_addr,
809 
810  /* Write a legitimate instruction at the point where the infcall
811  breakpoint is going to be inserted. While this instruction
812  is never going to be executed, a user investigating the
813  memory from GDB would see this instruction instead of random
814  uninitialized bytes. We chose the breakpoint instruction
815  as it may look as the most logical one to the user and also
816  valgrind 3.7.0 needs it for proper vgdb inferior calls.
817 
818  If software breakpoints are unsupported for this target we
819  leave the user visible memory content uninitialized. */
820 
821  bp_addr_as_address = bp_addr;
822  bp_bytes = gdbarch_breakpoint_from_pc (gdbarch, &bp_addr_as_address,
823  &bp_size);
824  if (bp_bytes != NULL)
825  write_memory (bp_addr_as_address, bp_bytes, bp_size);
826  }
827  break;
828  case AT_ENTRY_POINT:
829  {
830  CORE_ADDR dummy_addr;
831 
832  real_pc = funaddr;
833  dummy_addr = entry_point_address ();
834 
835  /* A call dummy always consists of just a single breakpoint, so
836  its address is the same as the address of the dummy.
837 
838  The actual breakpoint is inserted separatly so there is no need to
839  write that out. */
840  bp_addr = dummy_addr;
841  break;
842  }
843  default:
844  internal_error (__FILE__, __LINE__, _("bad switch"));
845  }
846 
847  if (nargs < TYPE_NFIELDS (ftype))
848  error (_("Too few arguments in function call."));
849 
850  {
851  int i;
852 
853  for (i = nargs - 1; i >= 0; i--)
854  {
855  int prototyped;
856  struct type *param_type;
857 
858  /* FIXME drow/2002-05-31: Should just always mark methods as
859  prototyped. Can we respect TYPE_VARARGS? Probably not. */
860  if (TYPE_CODE (ftype) == TYPE_CODE_METHOD)
861  prototyped = 1;
862  else if (i < TYPE_NFIELDS (ftype))
863  prototyped = TYPE_PROTOTYPED (ftype);
864  else
865  prototyped = 0;
866 
867  if (i < TYPE_NFIELDS (ftype))
868  param_type = TYPE_FIELD_TYPE (ftype, i);
869  else
870  param_type = NULL;
871 
872  args[i] = value_arg_coerce (gdbarch, args[i],
873  param_type, prototyped, &sp);
874 
875  if (param_type != NULL && language_pass_by_reference (param_type))
876  args[i] = value_addr (args[i]);
877  }
878  }
879 
880  /* Reserve space for the return structure to be written on the
881  stack, if necessary. Make certain that the value is correctly
882  aligned.
883 
884  While evaluating expressions, we reserve space on the stack for
885  return values of class type even if the language ABI and the target
886  ABI do not require that the return value be passed as a hidden first
887  argument. This is because we want to store the return value as an
888  on-stack temporary while the expression is being evaluated. This
889  enables us to have chained function calls in expressions.
890 
891  Keeping the return values as on-stack temporaries while the expression
892  is being evaluated is OK because the thread is stopped until the
893  expression is completely evaluated. */
894 
895  if (struct_return || hidden_first_param_p
896  || (stack_temporaries && class_or_union_p (values_type)))
897  {
898  if (gdbarch_inner_than (gdbarch, 1, 2))
899  {
900  /* Stack grows downward. Align STRUCT_ADDR and SP after
901  making space for the return value. */
902  sp -= TYPE_LENGTH (values_type);
903  if (gdbarch_frame_align_p (gdbarch))
904  sp = gdbarch_frame_align (gdbarch, sp);
905  struct_addr = sp;
906  }
907  else
908  {
909  /* Stack grows upward. Align the frame, allocate space, and
910  then again, re-align the frame??? */
911  if (gdbarch_frame_align_p (gdbarch))
912  sp = gdbarch_frame_align (gdbarch, sp);
913  struct_addr = sp;
914  sp += TYPE_LENGTH (values_type);
915  if (gdbarch_frame_align_p (gdbarch))
916  sp = gdbarch_frame_align (gdbarch, sp);
917  }
918  }
919 
920  if (hidden_first_param_p)
921  {
922  struct value **new_args;
923 
924  /* Add the new argument to the front of the argument list. */
925  new_args = xmalloc (sizeof (struct value *) * (nargs + 1));
926  new_args[0] = value_from_pointer (lookup_pointer_type (values_type),
927  struct_addr);
928  memcpy (&new_args[1], &args[0], sizeof (struct value *) * nargs);
929  args = new_args;
930  nargs++;
931  args_cleanup = make_cleanup (xfree, args);
932  }
933  else
934  args_cleanup = make_cleanup (null_cleanup, NULL);
935 
936  /* Create the dummy stack frame. Pass in the call dummy address as,
937  presumably, the ABI code knows where, in the call dummy, the
938  return address should be pointed. */
939  sp = gdbarch_push_dummy_call (gdbarch, function, get_current_regcache (),
940  bp_addr, nargs, args,
941  sp, struct_return, struct_addr);
942 
943  do_cleanups (args_cleanup);
944 
945  /* Set up a frame ID for the dummy frame so we can pass it to
946  set_momentary_breakpoint. We need to give the breakpoint a frame
947  ID so that the breakpoint code can correctly re-identify the
948  dummy breakpoint. */
949  /* Sanity. The exact same SP value is returned by PUSH_DUMMY_CALL,
950  saved as the dummy-frame TOS, and used by dummy_id to form
951  the frame ID's stack address. */
952  dummy_id = frame_id_build (sp, bp_addr);
953 
954  /* Create a momentary breakpoint at the return address of the
955  inferior. That way it breaks when it returns. */
956 
957  {
958  struct breakpoint *bpt, *longjmp_b;
959  struct symtab_and_line sal;
960 
961  init_sal (&sal); /* initialize to zeroes */
963  sal.pc = bp_addr;
964  sal.section = find_pc_overlay (sal.pc);
965  /* Sanity. The exact same SP value is returned by
966  PUSH_DUMMY_CALL, saved as the dummy-frame TOS, and used by
967  dummy_id to form the frame ID's stack address. */
968  bpt = set_momentary_breakpoint (gdbarch, sal, dummy_id, bp_call_dummy);
969 
970  /* set_momentary_breakpoint invalidates FRAME. */
971  frame = NULL;
972 
973  bpt->disposition = disp_del;
974  gdb_assert (bpt->related_breakpoint == bpt);
975 
977  if (longjmp_b)
978  {
979  /* Link BPT into the chain of LONGJMP_B. */
980  bpt->related_breakpoint = longjmp_b;
981  while (longjmp_b->related_breakpoint != bpt->related_breakpoint)
982  longjmp_b = longjmp_b->related_breakpoint;
983  longjmp_b->related_breakpoint = bpt;
984  }
985  }
986 
987  /* Create a breakpoint in std::terminate.
988  If a C++ exception is raised in the dummy-frame, and the
989  exception handler is (normally, and expected to be) out-of-frame,
990  the default C++ handler will (wrongly) be called in an inferior
991  function call. This is wrong, as an exception can be normally
992  and legally handled out-of-frame. The confines of the dummy frame
993  prevent the unwinder from finding the correct handler (or any
994  handler, unless it is in-frame). The default handler calls
995  std::terminate. This will kill the inferior. Assert that
996  terminate should never be called in an inferior function
997  call. Place a momentary breakpoint in the std::terminate function
998  and if triggered in the call, rewind. */
1001 
1002  /* Discard both inf_status and caller_state cleanups.
1003  From this point on we explicitly restore the associated state
1004  or discard it. */
1005  discard_cleanups (inf_status_cleanup);
1006 
1007  /* Everything's ready, push all the info needed to restore the
1008  caller (and identify the dummy-frame) onto the dummy-frame
1009  stack. */
1010  dummy_frame_push (caller_state, &dummy_id, inferior_ptid);
1011  if (dummy_dtor != NULL)
1013  dummy_dtor, dummy_dtor_data);
1014 
1015  /* dummy_frame_context_saver_setup must be called last so that its
1016  saving of inferior registers gets called first (before possible
1017  DUMMY_DTOR destructor). */
1018  context_saver = dummy_frame_context_saver_setup (dummy_id, inferior_ptid);
1019  context_saver_cleanup = make_cleanup (dummy_frame_context_saver_cleanup,
1020  context_saver);
1021 
1022  /* Register a clean-up for unwind_on_terminating_exception_breakpoint. */
1023  terminate_bp_cleanup = make_cleanup (cleanup_delete_std_terminate_breakpoint,
1024  NULL);
1025 
1026  /* - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP -
1027  If you're looking to implement asynchronous dummy-frames, then
1028  just below is the place to chop this function in two.. */
1029 
1030  /* TP is invalid after run_inferior_call returns, so enclose this
1031  in a block so that it's only in scope during the time it's valid. */
1032  {
1033  struct thread_info *tp = inferior_thread ();
1034 
1035  /* Save this thread's ptid, we need it later but the thread
1036  may have exited. */
1037  call_thread_ptid = tp->ptid;
1038 
1039  /* Run the inferior until it stops. */
1040 
1041  e = run_inferior_call (tp, real_pc);
1042  }
1043 
1044  observer_notify_inferior_call_post (call_thread_ptid, funaddr);
1045 
1046  /* Rethrow an error if we got one trying to run the inferior. */
1047 
1048  if (e.reason < 0)
1049  {
1050  const char *name = get_function_name (funaddr,
1051  name_buf, sizeof (name_buf));
1052 
1053  discard_infcall_control_state (inf_status);
1054 
1055  /* We could discard the dummy frame here if the program exited,
1056  but it will get garbage collected the next time the program is
1057  run anyway. */
1058 
1059  switch (e.reason)
1060  {
1061  case RETURN_ERROR:
1062  throw_error (e.error, _("%s\n\
1063 An error occurred while in a function called from GDB.\n\
1064 Evaluation of the expression containing the function\n\
1065 (%s) will be abandoned.\n\
1066 When the function is done executing, GDB will silently stop."),
1067  e.message, name);
1068  case RETURN_QUIT:
1069  default:
1070  throw_exception (e);
1071  }
1072  }
1073 
1074  /* If the program has exited, or we stopped at a different thread,
1075  exit and inform the user. */
1076 
1077  if (! target_has_execution)
1078  {
1079  const char *name = get_function_name (funaddr,
1080  name_buf, sizeof (name_buf));
1081 
1082  /* If we try to restore the inferior status,
1083  we'll crash as the inferior is no longer running. */
1084  discard_infcall_control_state (inf_status);
1085 
1086  /* We could discard the dummy frame here given that the program exited,
1087  but it will get garbage collected the next time the program is
1088  run anyway. */
1089 
1090  error (_("The program being debugged exited while in a function "
1091  "called from GDB.\n"
1092  "Evaluation of the expression containing the function\n"
1093  "(%s) will be abandoned."),
1094  name);
1095  }
1096 
1097  if (! ptid_equal (call_thread_ptid, inferior_ptid))
1098  {
1099  const char *name = get_function_name (funaddr,
1100  name_buf, sizeof (name_buf));
1101 
1102  /* We've switched threads. This can happen if another thread gets a
1103  signal or breakpoint while our thread was running.
1104  There's no point in restoring the inferior status,
1105  we're in a different thread. */
1106  discard_infcall_control_state (inf_status);
1107  /* Keep the dummy frame record, if the user switches back to the
1108  thread with the hand-call, we'll need it. */
1110  error (_("\
1111 The program received a signal in another thread while\n\
1112 making a function call from GDB.\n\
1113 Evaluation of the expression containing the function\n\
1114 (%s) will be abandoned.\n\
1115 When the function is done executing, GDB will silently stop."),
1116  name);
1117  else
1118  error (_("\
1119 The program stopped in another thread while making a function call from GDB.\n\
1120 Evaluation of the expression containing the function\n\
1121 (%s) will be abandoned.\n\
1122 When the function is done executing, GDB will silently stop."),
1123  name);
1124  }
1125 
1127  {
1128  /* Make a copy as NAME may be in an objfile freed by dummy_frame_pop. */
1129  char *name = xstrdup (get_function_name (funaddr,
1130  name_buf, sizeof (name_buf)));
1131  make_cleanup (xfree, name);
1132 
1133 
1135  {
1136  /* We stopped inside the FUNCTION because of a random
1137  signal. Further execution of the FUNCTION is not
1138  allowed. */
1139 
1140  if (unwind_on_signal_p)
1141  {
1142  /* The user wants the context restored. */
1143 
1144  /* We must get back to the frame we were before the
1145  dummy call. */
1146  dummy_frame_pop (dummy_id, call_thread_ptid);
1147 
1148  /* We also need to restore inferior status to that before the
1149  dummy call. */
1150  restore_infcall_control_state (inf_status);
1151 
1152  /* FIXME: Insert a bunch of wrap_here; name can be very
1153  long if it's a C++ name with arguments and stuff. */
1154  error (_("\
1155 The program being debugged was signaled while in a function called from GDB.\n\
1156 GDB has restored the context to what it was before the call.\n\
1157 To change this behavior use \"set unwindonsignal off\".\n\
1158 Evaluation of the expression containing the function\n\
1159 (%s) will be abandoned."),
1160  name);
1161  }
1162  else
1163  {
1164  /* The user wants to stay in the frame where we stopped
1165  (default).
1166  Discard inferior status, we're not at the same point
1167  we started at. */
1168  discard_infcall_control_state (inf_status);
1169 
1170  /* FIXME: Insert a bunch of wrap_here; name can be very
1171  long if it's a C++ name with arguments and stuff. */
1172  error (_("\
1173 The program being debugged was signaled while in a function called from GDB.\n\
1174 GDB remains in the frame where the signal was received.\n\
1175 To change this behavior use \"set unwindonsignal on\".\n\
1176 Evaluation of the expression containing the function\n\
1177 (%s) will be abandoned.\n\
1178 When the function is done executing, GDB will silently stop."),
1179  name);
1180  }
1181  }
1182 
1184  {
1185  /* We must get back to the frame we were before the dummy
1186  call. */
1187  dummy_frame_pop (dummy_id, call_thread_ptid);
1188 
1189  /* We also need to restore inferior status to that before
1190  the dummy call. */
1191  restore_infcall_control_state (inf_status);
1192 
1193  error (_("\
1194 The program being debugged entered a std::terminate call, most likely\n\
1195 caused by an unhandled C++ exception. GDB blocked this call in order\n\
1196 to prevent the program from being terminated, and has restored the\n\
1197 context to its original state before the call.\n\
1198 To change this behaviour use \"set unwind-on-terminating-exception off\".\n\
1199 Evaluation of the expression containing the function (%s)\n\
1200 will be abandoned."),
1201  name);
1202  }
1203  else if (stop_stack_dummy == STOP_NONE)
1204  {
1205 
1206  /* We hit a breakpoint inside the FUNCTION.
1207  Keep the dummy frame, the user may want to examine its state.
1208  Discard inferior status, we're not at the same point
1209  we started at. */
1210  discard_infcall_control_state (inf_status);
1211 
1212  /* The following error message used to say "The expression
1213  which contained the function call has been discarded."
1214  It is a hard concept to explain in a few words. Ideally,
1215  GDB would be able to resume evaluation of the expression
1216  when the function finally is done executing. Perhaps
1217  someday this will be implemented (it would not be easy). */
1218  /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1219  a C++ name with arguments and stuff. */
1220  error (_("\
1221 The program being debugged stopped while in a function called from GDB.\n\
1222 Evaluation of the expression containing the function\n\
1223 (%s) will be abandoned.\n\
1224 When the function is done executing, GDB will silently stop."),
1225  name);
1226  }
1227 
1228  /* The above code errors out, so ... */
1229  internal_error (__FILE__, __LINE__, _("... should not be here"));
1230  }
1231 
1232  do_cleanups (terminate_bp_cleanup);
1233 
1234  /* If we get here the called FUNCTION ran to completion,
1235  and the dummy frame has already been popped. */
1236 
1237  {
1238  struct value *retval = NULL;
1239 
1240  /* Inferior call is successful. Restore the inferior status.
1241  At this stage, leave the RETBUF alone. */
1242  restore_infcall_control_state (inf_status);
1243 
1244  if (TYPE_CODE (values_type) == TYPE_CODE_VOID)
1245  retval = allocate_value (values_type);
1246  else if (struct_return || hidden_first_param_p)
1247  {
1248  if (stack_temporaries)
1249  {
1250  retval = value_from_contents_and_address (values_type, NULL,
1251  struct_addr);
1253  }
1254  else
1255  {
1256  retval = allocate_value (values_type);
1257  read_value_memory (retval, 0, 1, struct_addr,
1258  value_contents_raw (retval),
1259  TYPE_LENGTH (values_type));
1260  }
1261  }
1262  else
1263  {
1264  retval = allocate_value (values_type);
1265  gdbarch_return_value (gdbarch, function, values_type,
1266  dummy_frame_context_saver_get_regs (context_saver),
1267  value_contents_raw (retval), NULL);
1268  if (stack_temporaries && class_or_union_p (values_type))
1269  {
1270  /* Values of class type returned in registers are copied onto
1271  the stack and their lval_type set to lval_memory. This is
1272  required because further evaluation of the expression
1273  could potentially invoke methods on the return value
1274  requiring GDB to evaluate the "this" pointer. To evaluate
1275  the this pointer, GDB needs the memory address of the
1276  value. */
1277  value_force_lval (retval, struct_addr);
1279  }
1280  }
1281 
1282  do_cleanups (context_saver_cleanup);
1283 
1284  gdb_assert (retval);
1285  return retval;
1286  }
1287 }
1288 
1289 
1290 /* Provide a prototype to silence -Wmissing-prototypes. */
1291 void _initialize_infcall (void);
1292 
1293 void
1295 {
1296  add_setshow_boolean_cmd ("coerce-float-to-double", class_obscure,
1298 Set coercion of floats to doubles when calling functions."), _("\
1299 Show coercion of floats to doubles when calling functions"), _("\
1300 Variables of type float should generally be converted to doubles before\n\
1301 calling an unprototyped function, and left alone when calling a prototyped\n\
1302 function. However, some older debug info formats do not provide enough\n\
1303 information to determine that a function is prototyped. If this flag is\n\
1304 set, GDB will perform the conversion for a function it considers\n\
1305 unprototyped.\n\
1306 The default is to perform the conversion.\n"),
1307  NULL,
1309  &setlist, &showlist);
1310 
1311  add_setshow_boolean_cmd ("unwindonsignal", no_class,
1312  &unwind_on_signal_p, _("\
1313 Set unwinding of stack if a signal is received while in a call dummy."), _("\
1314 Show unwinding of stack if a signal is received while in a call dummy."), _("\
1315 The unwindonsignal lets the user determine what gdb should do if a signal\n\
1316 is received while in a function called from gdb (call dummy). If set, gdb\n\
1317 unwinds the stack and restore the context to what as it was before the call.\n\
1318 The default is to stop in the frame where the signal was received."),
1319  NULL,
1321  &setlist, &showlist);
1322 
1323  add_setshow_boolean_cmd ("unwind-on-terminating-exception", no_class,
1325 Set unwinding of stack if std::terminate is called while in call dummy."), _("\
1326 Show unwinding of stack if std::terminate() is called while in a call dummy."),
1327  _("\
1328 The unwind on terminating exception flag lets the user determine\n\
1329 what gdb should do if a std::terminate() call is made from the\n\
1330 default exception handler. If set, gdb unwinds the stack and restores\n\
1331 the context to what it was before the call. If unset, gdb allows the\n\
1332 std::terminate call to proceed.\n\
1333 The default is to unwind the frame."),
1334  NULL,
1336  &setlist, &showlist);
1337 
1338 }
#define target_can_async_p()
Definition: target.h:1748
void restore_infcall_control_state(struct infcall_control_state *)
Definition: infrun.c:7450
ptid_t user_visible_resume_ptid(int step)
Definition: infrun.c:2021
void normal_stop(void)
Definition: infrun.c:6551
struct value * call_function_by_hand(struct value *function, int nargs, struct value **args)
Definition: infcall.c:488
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
Definition: frame.c:554
struct thread_info * find_thread_ptid(ptid_t ptid)
Definition: thread.c:393
int class_or_union_p(const struct type *t)
Definition: gdbtypes.c:2767
struct value * value_addr(struct value *arg1)
Definition: valops.c:1472
struct type * builtin_long_double
Definition: gdbtypes.h:1492
#define SYMBOL_PRINT_NAME(symbol)
Definition: symtab.h:260
static int coerce_float_to_double_p
Definition: infcall.c:73
struct frame_info * get_current_frame(void)
Definition: frame.c:1461
int ptid_equal(ptid_t ptid1, ptid_t ptid2)
Definition: ptid.c:76
struct value * value_from_contents_and_address(struct type *type, const gdb_byte *valaddr, CORE_ADDR address)
Definition: value.c:3529
bfd_vma CORE_ADDR
Definition: common-types.h:41
static const char * get_function_name(CORE_ADDR funaddr, char *buf, int buf_size)
Definition: infcall.c:347
void xfree(void *)
Definition: common-utils.c:97
CORE_ADDR gdbarch_frame_align(struct gdbarch *gdbarch, CORE_ADDR address)
Definition: gdbarch.c:2925
int gdbarch_push_dummy_code_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:2240
struct value * value_ref(struct value *arg1)
Definition: valops.c:1516
int gdbarch_inner_than(struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs)
Definition: gdbarch.c:2645
struct infcall_suspend_state * save_infcall_suspend_state(void)
Definition: infrun.c:7269
LONGEST value_as_long(struct value *val)
Definition: value.c:2654
void dummy_frame_pop(struct frame_id dummy_id, ptid_t ptid)
Definition: dummy-frame.c:205
void breakpoint_auto_delete(bpstat bs)
Definition: breakpoint.c:11914
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition: gdbtypes.c:4766
void register_dummy_frame_dtor(struct frame_id dummy_id, ptid_t ptid, dummy_frame_dtor_ftype *dtor, void *dtor_data)
Definition: dummy-frame.c:234
CORE_ADDR get_frame_sp(struct frame_info *this_frame)
Definition: frame.c:2577
enum errors error
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
struct thread_info * inferior_thread(void)
Definition: thread.c:85
void init_sal(struct symtab_and_line *sal)
Definition: symtab.c:1064
CORE_ADDR gdbarch_deprecated_function_start_offset(struct gdbarch *gdbarch)
Definition: gdbarch.c:2771
int thread_stack_temporaries_enabled_p(ptid_t ptid)
Definition: thread.c:694
static int unwind_on_terminating_exception_p
Definition: infcall.c:114
const struct gdb_exception exception_none
#define ON_STACK
Definition: inferior.h:258
enum language la_language
Definition: language.h:152
struct obj_section * section
Definition: symtab.h:1370
#define _(String)
Definition: gdb_locale.h:40
struct cleanup * make_cleanup_restore_infcall_suspend_state(struct infcall_suspend_state *)
Definition: infrun.c:7357
#define BLOCK_START(bl)
Definition: block.h:116
struct value * call_function_by_hand_dummy(struct value *function, int nargs, struct value **args, dummy_frame_dtor_ftype *dummy_dtor, void *dummy_dtor_data)
Definition: infcall.c:602
#define TYPE_PROTOTYPED(t)
Definition: gdbtypes.h:267
#define TYPE_FIELD_TYPE(thistype, n)
Definition: gdbtypes.h:1368
#define END_CATCH
#define VALUE_LVAL(val)
Definition: value.h:411
struct value * allocate_value(struct type *type)
Definition: value.c:962
struct regcache * dummy_frame_context_saver_get_regs(struct dummy_frame_context_saver *saver)
Definition: infcall.c:560
struct regcache * get_current_regcache(void)
Definition: regcache.c:541
Definition: ptid.h:35
struct obj_section * find_pc_overlay(CORE_ADDR pc)
Definition: symfile.c:3287
struct regcache * regcache_dup(struct regcache *src)
Definition: regcache.c:436
void null_cleanup(void *arg)
Definition: cleanups.c:295
enum bpdisp disposition
Definition: breakpoint.h:673
#define TRY
#define MSYMBOL_PRINT_NAME(symbol)
Definition: symtab.h:410
struct cmd_list_element * setlist
Definition: cli-cmds.c:135
#define AT_ENTRY_POINT
Definition: inferior.h:259
const char *const name
Definition: aarch64-tdep.c:68
int gdbarch_call_dummy_location(struct gdbarch *gdbarch)
Definition: gdbarch.c:2223
int gdbarch_frame_align_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:2918
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2217
#define TYPE_GNU_IFUNC(t)
Definition: gdbtypes.h:318
#define CATCH(EXCEPTION, MASK)
void dummy_frame_push(struct infcall_suspend_state *caller_state, const struct frame_id *dummy_id, ptid_t ptid)
Definition: dummy-frame.c:91
struct target_ops current_target
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2351
static void dummy_frame_context_saver_dtor(void *data_voidp, int registers_valid)
Definition: infcall.c:521
struct symbol * find_pc_function(CORE_ADDR pc)
Definition: blockframe.c:150
struct value * value_cast_pointers(struct type *type, struct value *arg2, int subclass_check)
Definition: valops.c:306
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:2247
CORE_ADDR gdbarch_convert_from_func_ptr_addr(struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ)
Definition: gdbarch.c:2975
int using_struct_return(struct gdbarch *gdbarch, struct value *function, struct type *value_type)
Definition: value.c:3756
struct cmd_list_element * showlist
Definition: cli-cmds.c:143
struct_return
Definition: arm-tdep.h:148
#define TYPE_VECTOR(t)
Definition: gdbtypes.h:287
int get_traceframe_number(void)
Definition: tracepoint.c:3180
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
int sync_execution
Definition: infrun.c:117
struct value * value_coerce_to_target(struct value *val)
Definition: valops.c:1398
Definition: gdbtypes.h:749
void( dummy_frame_dtor_ftype)(void *data, int registers_valid)
Definition: dummy-frame.h:59
void finish_thread_state(ptid_t ptid)
Definition: thread.c:911
struct gdbarch * get_type_arch(const struct type *type)
Definition: gdbtypes.c:232
void _initialize_infcall(void)
Definition: infcall.c:1294
enum return_value_convention gdbarch_return_value(struct gdbarch *gdbarch, struct value *function, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
Definition: gdbarch.c:2546
#define gdb_assert(expr)
Definition: gdb_assert.h:33
void push_thread_stack_temporary(ptid_t ptid, struct value *v)
Definition: thread.c:707
struct value * value_cast(struct type *type, struct value *arg2)
Definition: valops.c:351
#define target_has_execution
Definition: target.h:1726
char * xstrprintf(const char *format,...)
Definition: common-utils.c:107
char c_style_arrays
Definition: language.h:291
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, int struct_return, CORE_ADDR struct_addr)
Definition: gdbarch.c:2206
void async_disable_stdin(void)
Definition: event-top.c:459
struct value * get_last_thread_stack_temporary(ptid_t)
Definition: thread.c:741
void * xmalloc(YYSIZE_T)
static CORE_ADDR 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: infcall.c:326
static struct gdb_exception run_inferior_call(struct thread_info *call_thread, CORE_ADDR real_pc)
Definition: infcall.c:384
struct breakpoint * set_momentary_breakpoint(struct gdbarch *gdbarch, struct symtab_and_line sal, struct frame_id frame_id, enum bptype type)
Definition: breakpoint.c:8756
struct regcache * retbuf
Definition: infcall.c:502
Definition: value.c:172
void disable_watchpoints_before_interactive_call_start(void)
Definition: breakpoint.c:8686
int stopped_by_random_signal
Definition: infcmd.c:137
void discard_infcall_control_state(struct infcall_control_state *)
Definition: infrun.c:7504
void throw_exception(struct gdb_exception exception)
bfd_byte gdb_byte
Definition: common-types.h:38
struct value * value_from_pointer(struct type *type, CORE_ADDR addr)
Definition: value.c:3490
void discard_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:213
const struct language_defn * current_language
Definition: language.c:85
CORE_ADDR entry_point_address(void)
Definition: objfiles.c:392
#define TYPE_TARGET_TYPE(thistype)
Definition: gdbtypes.h:1229
int gdbarch_frame_red_zone_size(struct gdbarch *gdbarch)
Definition: gdbarch.c:2959
struct type * builtin_double
Definition: gdbtypes.h:1491
struct bound_minimal_symbol lookup_minimal_symbol_by_pc(CORE_ADDR pc)
Definition: minsyms.c:801
struct dummy_frame_context_saver * dummy_frame_context_saver_setup(struct frame_id dummy_id, ptid_t ptid)
Definition: infcall.c:571
void proceed(CORE_ADDR addr, enum gdb_signal siggnal)
Definition: infrun.c:2592
ptid_t ptid
Definition: gdbthread.h:169
#define SYMBOL_BLOCK_VALUE(symbol)
Definition: symtab.h:185
struct breakpoint * set_longjmp_breakpoint_for_call_dummy(void)
Definition: breakpoint.c:7500
#define RAW_FUNCTION_ADDRESS_FORMAT
Definition: infcall.c:42
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1240
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:117
void clear_proceed_status(int step)
Definition: infrun.c:2463
void read_value_memory(struct value *val, int embedded_offset, int stack, CORE_ADDR memaddr, gdb_byte *buffer, size_t length)
Definition: valops.c:957
const gdb_byte * gdbarch_breakpoint_from_pc(struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
Definition: gdbarch.c:2662
CORE_ADDR find_function_addr(struct value *function, struct type **retval_type)
Definition: infcall.c:247
ptid_t inferior_ptid
Definition: infcmd.c:124
struct minimal_symbol * minsym
Definition: minsyms.h:32
struct program_space * pspace
Definition: symtab.h:1367
#define TYPE_NFIELDS(thistype)
Definition: gdbtypes.h:1241
void set_std_terminate_breakpoint(void)
Definition: breakpoint.c:7595
static struct value * value_arg_coerce(struct gdbarch *gdbarch, struct value *arg, struct type *param_type, int is_prototyped, CORE_ADDR *sp)
Definition: infcall.c:137
CORE_ADDR pc
Definition: symtab.h:1376
#define CHECK_TYPEDEF(TYPE)
Definition: gdbtypes.h:1817
void observer_notify_inferior_call_post(ptid_t thread, CORE_ADDR address)
void regcache_xfree(struct regcache *regcache)
Definition: regcache.c:247
struct breakpoint * related_breakpoint
Definition: breakpoint.h:736
void observer_notify_inferior_call_pre(ptid_t thread, CORE_ADDR address)
struct program_space * current_program_space
Definition: progspace.c:35
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:93
static int ignore(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: corelow.c:917
const char * message
void value_force_lval(struct value *v, CORE_ADDR addr)
Definition: value.c:1751
static void cleanup_delete_std_terminate_breakpoint(void *ignore)
Definition: infcall.c:480
struct type * value_type(const struct value *value)
Definition: value.c:1021
#define SYMBOL_TYPE(symbol)
Definition: symtab.h:799
Definition: symtab.h:703
struct value * ada_convert_actual(struct value *actual, struct type *formal_type0)
Definition: ada-lang.c:4315
void dummy_frame_context_saver_drop(struct dummy_frame_context_saver *saver)
Definition: infcall.c:538
CORE_ADDR value_as_address(struct value *val)
Definition: value.c:2679
void dummy_frame_context_saver_cleanup(void *data)
Definition: infcall.c:549
void wait_for_inferior(void)
Definition: infrun.c:3165
int gdbarch_push_dummy_call_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:2199
gdb_byte * value_contents_raw(struct value *value)
Definition: value.c:1084
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:75
void delete_std_terminate_breakpoint(void)
Definition: breakpoint.c:7610
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1237
enum stop_stack_kind stop_stack_dummy
Definition: infcmd.c:132
int execution_direction
Definition: infrun.c:7561
static struct type * find_function_return_type(CORE_ADDR pc)
Definition: infcall.c:232
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
Definition: corefile.c:389
#define RAW_FUNCTION_ADDRESS_SIZE
Definition: infcall.c:43
CORE_ADDR value_address(const struct value *value)
Definition: value.c:1440
void enable_watchpoints_after_interactive_call_stop(void)
Definition: breakpoint.c:8701
void noprocess(void)
Definition: target.c:570
static int unwind_on_signal_p
Definition: infcall.c:91
int find_dummy_frame_dtor(dummy_frame_dtor_ftype *dtor, void *dtor_data)
Definition: dummy-frame.c:254
static void dummy_frame_context_saver_free(struct dummy_frame_context_saver *saver)
Definition: infcall.c:512
struct type * builtin_void
Definition: gdbtypes.h:1480
void error(const char *fmt,...)
Definition: errors.c:38
struct type * lookup_pointer_type(struct type *type)
Definition: gdbtypes.c:368
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
Definition: frame.c:2535
struct cleanup * make_cleanup_restore_infcall_control_state(struct infcall_control_state *)
Definition: infrun.c:7498
void throw_error(enum errors error, const char *fmt,...)
#define gnu_ifunc_resolve_addr
Definition: symtab.h:1354
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
void add_setshow_boolean_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:541
int language_pass_by_reference(struct type *type)
Definition: language.c:650
enum return_reason reason
struct type * builtin_int
Definition: gdbtypes.h:1483
struct infcall_control_state * save_infcall_control_state(void)
Definition: infrun.c:7398
int gdbarch_return_in_first_hidden_param_p(struct gdbarch *gdbarch, struct type *type)
Definition: gdbarch.c:2563