gdb/infcall.c

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