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