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 struct gdbarch *gdbarch = get_type_arch (ftype); 235 enum type_code code = TYPE_CODE (ftype); 236 struct type *value_type = NULL; 237 CORE_ADDR funaddr; 238 239 /* If it's a member function, just look at the function 240 part of it. */ 241 242 /* Determine address to call. */ 243 if (code == TYPE_CODE_FUNC || code == TYPE_CODE_METHOD) 244 { 245 funaddr = value_address (function); 246 value_type = TYPE_TARGET_TYPE (ftype); 247 } 248 else if (code == TYPE_CODE_PTR) 249 { 250 funaddr = value_as_address (function); 251 ftype = check_typedef (TYPE_TARGET_TYPE (ftype)); 252 if (TYPE_CODE (ftype) == TYPE_CODE_FUNC 253 || TYPE_CODE (ftype) == TYPE_CODE_METHOD) 254 { 255 funaddr = gdbarch_convert_from_func_ptr_addr (gdbarch, funaddr, 256 ¤t_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 (gdbarch, funaddr, 277 ¤t_target); 278 if (funaddr != nfunaddr) 279 found_descriptor = 1; 280 } 281 if (!found_descriptor) 282 /* Handle integer used as address of a function. */ 283 funaddr = (CORE_ADDR) value_as_long (function); 284 } 285 } 286 else 287 error (_("Invalid data type for function to be called.")); 288 289 if (retval_type != NULL) 290 *retval_type = value_type; 291 return funaddr + gdbarch_deprecated_function_start_offset (gdbarch); 292 } 293 294 /* For CALL_DUMMY_ON_STACK, push a breakpoint sequence that the called 295 function returns to. */ 296 297 static CORE_ADDR 298 push_dummy_code (struct gdbarch *gdbarch, 299 CORE_ADDR sp, CORE_ADDR funaddr, 300 struct value **args, int nargs, 301 struct type *value_type, 302 CORE_ADDR *real_pc, CORE_ADDR *bp_addr, 303 struct regcache *regcache) 304 { 305 gdb_assert (gdbarch_push_dummy_code_p (gdbarch)); 306 307 return gdbarch_push_dummy_code (gdbarch, sp, funaddr, 308 args, nargs, value_type, real_pc, bp_addr, 309 regcache); 310 } 311 312 /* Fetch the name of the function at FUNADDR. 313 This is used in printing an error message for call_function_by_hand. 314 BUF is used to print FUNADDR in hex if the function name cannot be 315 determined. It must be large enough to hold formatted result of 316 RAW_FUNCTION_ADDRESS_FORMAT. */ 317 318 static const char * 319 get_function_name (CORE_ADDR funaddr, char *buf, int buf_size) 320 { 321 { 322 struct symbol *symbol = find_pc_function (funaddr); 323 if (symbol) 324 return SYMBOL_PRINT_NAME (symbol); 325 } 326 327 { 328 /* Try the minimal symbols. */ 329 struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (funaddr); 330 if (msymbol) 331 return SYMBOL_PRINT_NAME (msymbol); 332 } 333 334 { 335 char *tmp = xstrprintf (_(RAW_FUNCTION_ADDRESS_FORMAT), 336 hex_string (funaddr)); 337 gdb_assert (strlen (tmp) + 1 <= buf_size); 338 strcpy (buf, tmp); 339 xfree (tmp); 340 return buf; 341 } 342 } 343 344 /* Subroutine of call_function_by_hand to simplify it. 345 Start up the inferior and wait for it to stop. 346 Return the exception if there's an error, or an exception with 347 reason >= 0 if there's no error. 348 349 This is done inside a TRY_CATCH so the caller needn't worry about 350 thrown errors. The caller should rethrow if there's an error. */ 351 352 static struct gdb_exception 353 run_inferior_call (struct thread_info *call_thread, CORE_ADDR real_pc) 354 { 355 volatile struct gdb_exception e; 356 int saved_async = 0; 357 int saved_in_infcall = call_thread->in_infcall; 358 ptid_t call_thread_ptid = call_thread->ptid; 359 char *saved_target_shortname = xstrdup (target_shortname); 360 361 call_thread->in_infcall = 1; 362 363 clear_proceed_status (); 364 365 disable_watchpoints_before_interactive_call_start (); 366 call_thread->proceed_to_finish = 1; /* We want stop_registers, please... */ 367 368 if (target_can_async_p ()) 369 saved_async = target_async_mask (0); 370 371 TRY_CATCH (e, RETURN_MASK_ALL) 372 proceed (real_pc, TARGET_SIGNAL_0, 0); 373 374 /* At this point the current thread may have changed. Refresh 375 CALL_THREAD as it could be invalid if its thread has exited. */ 376 call_thread = find_thread_ptid (call_thread_ptid); 377 378 /* Don't restore the async mask if the target has changed, 379 saved_async is for the original target. */ 380 if (saved_async 381 && strcmp (saved_target_shortname, target_shortname) == 0) 382 target_async_mask (saved_async); 383 384 enable_watchpoints_after_interactive_call_stop (); 385 386 /* Call breakpoint_auto_delete on the current contents of the bpstat 387 of inferior call thread. 388 If all error()s out of proceed ended up calling normal_stop 389 (and perhaps they should; it already does in the special case 390 of error out of resume()), then we wouldn't need this. */ 391 if (e.reason < 0) 392 { 393 if (call_thread != NULL) 394 breakpoint_auto_delete (call_thread->stop_bpstat); 395 } 396 397 if (call_thread != NULL) 398 call_thread->in_infcall = saved_in_infcall; 399 400 xfree (saved_target_shortname); 401 402 return e; 403 } 404 405 /* All this stuff with a dummy frame may seem unnecessarily complicated 406 (why not just save registers in GDB?). The purpose of pushing a dummy 407 frame which looks just like a real frame is so that if you call a 408 function and then hit a breakpoint (get a signal, etc), "backtrace" 409 will look right. Whether the backtrace needs to actually show the 410 stack at the time the inferior function was called is debatable, but 411 it certainly needs to not display garbage. So if you are contemplating 412 making dummy frames be different from normal frames, consider that. */ 413 414 /* Perform a function call in the inferior. 415 ARGS is a vector of values of arguments (NARGS of them). 416 FUNCTION is a value, the function to be called. 417 Returns a value representing what the function returned. 418 May fail to return, if a breakpoint or signal is hit 419 during the execution of the function. 420 421 ARGS is modified to contain coerced values. */ 422 423 struct value * 424 call_function_by_hand (struct value *function, int nargs, struct value **args) 425 { 426 CORE_ADDR sp; 427 struct type *values_type, *target_values_type; 428 unsigned char struct_return = 0, lang_struct_return = 0; 429 CORE_ADDR struct_addr = 0; 430 struct inferior_status *inf_status; 431 struct cleanup *inf_status_cleanup; 432 struct inferior_thread_state *caller_state; 433 struct cleanup *caller_state_cleanup; 434 CORE_ADDR funaddr; 435 CORE_ADDR real_pc; 436 struct type *ftype = check_typedef (value_type (function)); 437 CORE_ADDR bp_addr; 438 struct frame_id dummy_id; 439 struct cleanup *args_cleanup; 440 struct frame_info *frame; 441 struct gdbarch *gdbarch; 442 struct breakpoint *terminate_bp = NULL; 443 struct minimal_symbol *tm; 444 ptid_t call_thread_ptid; 445 struct gdb_exception e; 446 const char *name; 447 char name_buf[RAW_FUNCTION_ADDRESS_SIZE]; 448 449 if (TYPE_CODE (ftype) == TYPE_CODE_PTR) 450 ftype = check_typedef (TYPE_TARGET_TYPE (ftype)); 451 452 if (!target_has_execution) 453 noprocess (); 454 455 frame = get_current_frame (); 456 gdbarch = get_frame_arch (frame); 457 458 if (!gdbarch_push_dummy_call_p (gdbarch)) 459 error (_("This target does not support function calls.")); 460 461 /* A cleanup for the inferior status. 462 This is only needed while we're preparing the inferior function call. */ 463 inf_status = save_inferior_status (); 464 inf_status_cleanup = make_cleanup_restore_inferior_status (inf_status); 465 466 /* Save the caller's registers and other state associated with the 467 inferior itself so that they can be restored once the 468 callee returns. To allow nested calls the registers are (further 469 down) pushed onto a dummy frame stack. Include a cleanup (which 470 is tossed once the regcache has been pushed). */ 471 caller_state = save_inferior_thread_state (); 472 caller_state_cleanup = make_cleanup_restore_inferior_thread_state (caller_state); 473 474 /* Ensure that the initial SP is correctly aligned. */ 475 { 476 CORE_ADDR old_sp = get_frame_sp (frame); 477 if (gdbarch_frame_align_p (gdbarch)) 478 { 479 sp = gdbarch_frame_align (gdbarch, old_sp); 480 /* NOTE: cagney/2003-08-13: Skip the "red zone". For some 481 ABIs, a function can use memory beyond the inner most stack 482 address. AMD64 called that region the "red zone". Skip at 483 least the "red zone" size before allocating any space on 484 the stack. */ 485 if (gdbarch_inner_than (gdbarch, 1, 2)) 486 sp -= gdbarch_frame_red_zone_size (gdbarch); 487 else 488 sp += gdbarch_frame_red_zone_size (gdbarch); 489 /* Still aligned? */ 490 gdb_assert (sp == gdbarch_frame_align (gdbarch, sp)); 491 /* NOTE: cagney/2002-09-18: 492 493 On a RISC architecture, a void parameterless generic dummy 494 frame (i.e., no parameters, no result) typically does not 495 need to push anything the stack and hence can leave SP and 496 FP. Similarly, a frameless (possibly leaf) function does 497 not push anything on the stack and, hence, that too can 498 leave FP and SP unchanged. As a consequence, a sequence of 499 void parameterless generic dummy frame calls to frameless 500 functions will create a sequence of effectively identical 501 frames (SP, FP and TOS and PC the same). This, not 502 suprisingly, results in what appears to be a stack in an 503 infinite loop --- when GDB tries to find a generic dummy 504 frame on the internal dummy frame stack, it will always 505 find the first one. 506 507 To avoid this problem, the code below always grows the 508 stack. That way, two dummy frames can never be identical. 509 It does burn a few bytes of stack but that is a small price 510 to pay :-). */ 511 if (sp == old_sp) 512 { 513 if (gdbarch_inner_than (gdbarch, 1, 2)) 514 /* Stack grows down. */ 515 sp = gdbarch_frame_align (gdbarch, old_sp - 1); 516 else 517 /* Stack grows up. */ 518 sp = gdbarch_frame_align (gdbarch, old_sp + 1); 519 } 520 gdb_assert ((gdbarch_inner_than (gdbarch, 1, 2) 521 && sp <= old_sp) 522 || (gdbarch_inner_than (gdbarch, 2, 1) 523 && sp >= old_sp)); 524 } 525 else 526 /* FIXME: cagney/2002-09-18: Hey, you loose! 527 528 Who knows how badly aligned the SP is! 529 530 If the generic dummy frame ends up empty (because nothing is 531 pushed) GDB won't be able to correctly perform back traces. 532 If a target is having trouble with backtraces, first thing to 533 do is add FRAME_ALIGN() to the architecture vector. If that 534 fails, try dummy_id(). 535 536 If the ABI specifies a "Red Zone" (see the doco) the code 537 below will quietly trash it. */ 538 sp = old_sp; 539 } 540 541 funaddr = find_function_addr (function, &values_type); 542 if (!values_type) 543 values_type = builtin_type (gdbarch)->builtin_int; 544 545 CHECK_TYPEDEF (values_type); 546 547 /* Are we returning a value using a structure return (passing a 548 hidden argument pointing to storage) or a normal value return? 549 There are two cases: language-mandated structure return and 550 target ABI structure return. The variable STRUCT_RETURN only 551 describes the latter. The language version is handled by passing 552 the return location as the first parameter to the function, 553 even preceding "this". This is different from the target 554 ABI version, which is target-specific; for instance, on ia64 555 the first argument is passed in out0 but the hidden structure 556 return pointer would normally be passed in r8. */ 557 558 if (language_pass_by_reference (values_type)) 559 { 560 lang_struct_return = 1; 561 562 /* Tell the target specific argument pushing routine not to 563 expect a value. */ 564 target_values_type = builtin_type (gdbarch)->builtin_void; 565 } 566 else 567 { 568 struct_return = using_struct_return (gdbarch, 569 value_type (function), values_type); 570 target_values_type = values_type; 571 } 572 573 /* Determine the location of the breakpoint (and possibly other 574 stuff) that the called function will return to. The SPARC, for a 575 function returning a structure or union, needs to make space for 576 not just the breakpoint but also an extra word containing the 577 size (?) of the structure being passed. */ 578 579 /* The actual breakpoint (at BP_ADDR) is inserted separatly so there 580 is no need to write that out. */ 581 582 switch (gdbarch_call_dummy_location (gdbarch)) 583 { 584 case ON_STACK: 585 sp = push_dummy_code (gdbarch, sp, funaddr, 586 args, nargs, target_values_type, 587 &real_pc, &bp_addr, get_current_regcache ()); 588 break; 589 case AT_ENTRY_POINT: 590 { 591 CORE_ADDR dummy_addr; 592 593 real_pc = funaddr; 594 dummy_addr = entry_point_address (); 595 /* A call dummy always consists of just a single breakpoint, so 596 its address is the same as the address of the dummy. */ 597 bp_addr = dummy_addr; 598 break; 599 } 600 case AT_SYMBOL: 601 /* Some executables define a symbol __CALL_DUMMY_ADDRESS whose 602 address is the location where the breakpoint should be 603 placed. Once all targets are using the overhauled frame code 604 this can be deleted - ON_STACK is a better option. */ 605 { 606 struct minimal_symbol *sym; 607 CORE_ADDR dummy_addr; 608 609 sym = lookup_minimal_symbol ("__CALL_DUMMY_ADDRESS", NULL, NULL); 610 real_pc = funaddr; 611 if (sym) 612 { 613 dummy_addr = SYMBOL_VALUE_ADDRESS (sym); 614 /* Make certain that the address points at real code, and not 615 a function descriptor. */ 616 dummy_addr = gdbarch_convert_from_func_ptr_addr (gdbarch, 617 dummy_addr, 618 ¤t_target); 619 } 620 else 621 dummy_addr = entry_point_address (); 622 /* A call dummy always consists of just a single breakpoint, 623 so it's address is the same as the address of the dummy. */ 624 bp_addr = dummy_addr; 625 break; 626 } 627 default: 628 internal_error (__FILE__, __LINE__, _("bad switch")); 629 } 630 631 if (nargs < TYPE_NFIELDS (ftype)) 632 error (_("Too few arguments in function call.")); 633 634 { 635 int i; 636 for (i = nargs - 1; i >= 0; i--) 637 { 638 int prototyped; 639 struct type *param_type; 640 641 /* FIXME drow/2002-05-31: Should just always mark methods as 642 prototyped. Can we respect TYPE_VARARGS? Probably not. */ 643 if (TYPE_CODE (ftype) == TYPE_CODE_METHOD) 644 prototyped = 1; 645 else if (i < TYPE_NFIELDS (ftype)) 646 prototyped = TYPE_PROTOTYPED (ftype); 647 else 648 prototyped = 0; 649 650 if (i < TYPE_NFIELDS (ftype)) 651 param_type = TYPE_FIELD_TYPE (ftype, i); 652 else 653 param_type = NULL; 654 655 args[i] = value_arg_coerce (gdbarch, args[i], 656 param_type, prototyped, &sp); 657 658 if (param_type != NULL && language_pass_by_reference (param_type)) 659 args[i] = value_addr (args[i]); 660 } 661 } 662 663 /* Reserve space for the return structure to be written on the 664 stack, if necessary. Make certain that the value is correctly 665 aligned. */ 666 667 if (struct_return || lang_struct_return) 668 { 669 int len = TYPE_LENGTH (values_type); 670 if (gdbarch_inner_than (gdbarch, 1, 2)) 671 { 672 /* Stack grows downward. Align STRUCT_ADDR and SP after 673 making space for the return value. */ 674 sp -= len; 675 if (gdbarch_frame_align_p (gdbarch)) 676 sp = gdbarch_frame_align (gdbarch, sp); 677 struct_addr = sp; 678 } 679 else 680 { 681 /* Stack grows upward. Align the frame, allocate space, and 682 then again, re-align the frame??? */ 683 if (gdbarch_frame_align_p (gdbarch)) 684 sp = gdbarch_frame_align (gdbarch, sp); 685 struct_addr = sp; 686 sp += len; 687 if (gdbarch_frame_align_p (gdbarch)) 688 sp = gdbarch_frame_align (gdbarch, sp); 689 } 690 } 691 692 if (lang_struct_return) 693 { 694 struct value **new_args; 695 696 /* Add the new argument to the front of the argument list. */ 697 new_args = xmalloc (sizeof (struct value *) * (nargs + 1)); 698 new_args[0] = value_from_pointer (lookup_pointer_type (values_type), 699 struct_addr); 700 memcpy (&new_args[1], &args[0], sizeof (struct value *) * nargs); 701 args = new_args; 702 nargs++; 703 args_cleanup = make_cleanup (xfree, args); 704 } 705 else 706 args_cleanup = make_cleanup (null_cleanup, NULL); 707 708 /* Create the dummy stack frame. Pass in the call dummy address as, 709 presumably, the ABI code knows where, in the call dummy, the 710 return address should be pointed. */ 711 sp = gdbarch_push_dummy_call (gdbarch, function, get_current_regcache (), 712 bp_addr, nargs, args, 713 sp, struct_return, struct_addr); 714 715 do_cleanups (args_cleanup); 716 717 /* Set up a frame ID for the dummy frame so we can pass it to 718 set_momentary_breakpoint. We need to give the breakpoint a frame 719 ID so that the breakpoint code can correctly re-identify the 720 dummy breakpoint. */ 721 /* Sanity. The exact same SP value is returned by PUSH_DUMMY_CALL, 722 saved as the dummy-frame TOS, and used by dummy_id to form 723 the frame ID's stack address. */ 724 dummy_id = frame_id_build (sp, bp_addr); 725 726 /* Create a momentary breakpoint at the return address of the 727 inferior. That way it breaks when it returns. */ 728 729 { 730 struct breakpoint *bpt; 731 struct symtab_and_line sal; 732 init_sal (&sal); /* initialize to zeroes */ 733 sal.pc = bp_addr; 734 sal.section = find_pc_overlay (sal.pc); 735 /* Sanity. The exact same SP value is returned by 736 PUSH_DUMMY_CALL, saved as the dummy-frame TOS, and used by 737 dummy_id to form the frame ID's stack address. */ 738 bpt = set_momentary_breakpoint (gdbarch, sal, dummy_id, bp_call_dummy); 739 bpt->disposition = disp_del; 740 } 741 742 /* Create a breakpoint in std::terminate. 743 If a C++ exception is raised in the dummy-frame, and the 744 exception handler is (normally, and expected to be) out-of-frame, 745 the default C++ handler will (wrongly) be called in an inferior 746 function call. This is wrong, as an exception can be normally 747 and legally handled out-of-frame. The confines of the dummy frame 748 prevent the unwinder from finding the correct handler (or any 749 handler, unless it is in-frame). The default handler calls 750 std::terminate. This will kill the inferior. Assert that 751 terminate should never be called in an inferior function 752 call. Place a momentary breakpoint in the std::terminate function 753 and if triggered in the call, rewind. */ 754 if (unwind_on_terminating_exception_p) 755 { 756 struct minimal_symbol *tm = lookup_minimal_symbol ("std::terminate()", 757 NULL, NULL); 758 if (tm != NULL) 759 terminate_bp = set_momentary_breakpoint_at_pc 760 (gdbarch, SYMBOL_VALUE_ADDRESS (tm), bp_breakpoint); 761 } 762 763 /* Everything's ready, push all the info needed to restore the 764 caller (and identify the dummy-frame) onto the dummy-frame 765 stack. */ 766 dummy_frame_push (caller_state, &dummy_id); 767 768 /* Discard both inf_status and caller_state cleanups. 769 From this point on we explicitly restore the associated state 770 or discard it. */ 771 discard_cleanups (inf_status_cleanup); 772 773 /* Register a clean-up for unwind_on_terminating_exception_breakpoint. */ 774 if (terminate_bp) 775 make_cleanup_delete_breakpoint (terminate_bp); 776 777 /* - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - 778 If you're looking to implement asynchronous dummy-frames, then 779 just below is the place to chop this function in two.. */ 780 781 /* TP is invalid after run_inferior_call returns, so enclose this 782 in a block so that it's only in scope during the time it's valid. */ 783 { 784 struct thread_info *tp = inferior_thread (); 785 786 /* Save this thread's ptid, we need it later but the thread 787 may have exited. */ 788 call_thread_ptid = tp->ptid; 789 790 /* Run the inferior until it stops. */ 791 792 e = run_inferior_call (tp, real_pc); 793 } 794 795 /* Rethrow an error if we got one trying to run the inferior. */ 796 797 if (e.reason < 0) 798 { 799 const char *name = get_function_name (funaddr, 800 name_buf, sizeof (name_buf)); 801 802 discard_inferior_status (inf_status); 803 804 /* We could discard the dummy frame here if the program exited, 805 but it will get garbage collected the next time the program is 806 run anyway. */ 807 808 switch (e.reason) 809 { 810 case RETURN_ERROR: 811 throw_error (e.error, _("\ 812 %s\n\ 813 An error occurred while in a function called from GDB.\n\ 814 Evaluation of the expression containing the function\n\ 815 (%s) will be abandoned.\n\ 816 When the function is done executing, GDB will silently stop."), 817 e.message, name); 818 case RETURN_QUIT: 819 default: 820 throw_exception (e); 821 } 822 } 823 824 /* If the program has exited, or we stopped at a different thread, 825 exit and inform the user. */ 826 827 if (! target_has_execution) 828 { 829 const char *name = get_function_name (funaddr, 830 name_buf, sizeof (name_buf)); 831 832 /* If we try to restore the inferior status, 833 we'll crash as the inferior is no longer running. */ 834 discard_inferior_status (inf_status); 835 836 /* We could discard the dummy frame here given that the program exited, 837 but it will get garbage collected the next time the program is 838 run anyway. */ 839 840 error (_("\ 841 The program being debugged exited while in a function called from GDB.\n\ 842 Evaluation of the expression containing the function\n\ 843 (%s) will be abandoned."), 844 name); 845 } 846 847 if (! ptid_equal (call_thread_ptid, inferior_ptid)) 848 { 849 const char *name = get_function_name (funaddr, 850 name_buf, sizeof (name_buf)); 851 852 /* We've switched threads. This can happen if another thread gets a 853 signal or breakpoint while our thread was running. 854 There's no point in restoring the inferior status, 855 we're in a different thread. */ 856 discard_inferior_status (inf_status); 857 /* Keep the dummy frame record, if the user switches back to the 858 thread with the hand-call, we'll need it. */ 859 if (stopped_by_random_signal) 860 error (_("\ 861 The program received a signal in another thread while\n\ 862 making a function call from GDB.\n\ 863 Evaluation of the expression containing the function\n\ 864 (%s) will be abandoned.\n\ 865 When the function is done executing, GDB will silently stop."), 866 name); 867 else 868 error (_("\ 869 The program stopped in another thread while making a function call from GDB.\n\ 870 Evaluation of the expression containing the function\n\ 871 (%s) will be abandoned.\n\ 872 When the function is done executing, GDB will silently stop."), 873 name); 874 } 875 876 if (stopped_by_random_signal || !stop_stack_dummy) 877 { 878 const char *name = get_function_name (funaddr, 879 name_buf, sizeof (name_buf)); 880 881 if (stopped_by_random_signal) 882 { 883 /* We stopped inside the FUNCTION because of a random 884 signal. Further execution of the FUNCTION is not 885 allowed. */ 886 887 if (unwind_on_signal_p) 888 { 889 /* The user wants the context restored. */ 890 891 /* We must get back to the frame we were before the 892 dummy call. */ 893 dummy_frame_pop (dummy_id); 894 895 /* We also need to restore inferior status to that before the 896 dummy call. */ 897 restore_inferior_status (inf_status); 898 899 /* FIXME: Insert a bunch of wrap_here; name can be very 900 long if it's a C++ name with arguments and stuff. */ 901 error (_("\ 902 The program being debugged was signaled while in a function called from GDB.\n\ 903 GDB has restored the context to what it was before the call.\n\ 904 To change this behavior use \"set unwindonsignal off\".\n\ 905 Evaluation of the expression containing the function\n\ 906 (%s) will be abandoned."), 907 name); 908 } 909 else 910 { 911 /* The user wants to stay in the frame where we stopped 912 (default). 913 Discard inferior status, we're not at the same point 914 we started at. */ 915 discard_inferior_status (inf_status); 916 917 /* FIXME: Insert a bunch of wrap_here; name can be very 918 long if it's a C++ name with arguments and stuff. */ 919 error (_("\ 920 The program being debugged was signaled while in a function called from GDB.\n\ 921 GDB remains in the frame where the signal was received.\n\ 922 To change this behavior use \"set unwindonsignal on\".\n\ 923 Evaluation of the expression containing the function\n\ 924 (%s) will be abandoned.\n\ 925 When the function is done executing, GDB will silently stop."), 926 name); 927 } 928 } 929 930 if (!stop_stack_dummy) 931 { 932 933 /* Check if unwind on terminating exception behaviour is on. */ 934 if (unwind_on_terminating_exception_p) 935 { 936 /* Check that the breakpoint is our special std::terminate 937 breakpoint. If it is, we do not want to kill the inferior 938 in an inferior function call. Rewind, and warn the 939 user. */ 940 941 if (terminate_bp != NULL 942 && (inferior_thread()->stop_bpstat->breakpoint_at->address 943 == terminate_bp->loc->address)) 944 { 945 /* We must get back to the frame we were before the 946 dummy call. */ 947 dummy_frame_pop (dummy_id); 948 949 /* We also need to restore inferior status to that before the 950 dummy call. */ 951 restore_inferior_status (inf_status); 952 953 error (_("\ 954 The program being debugged entered a std::terminate call, most likely\n\ 955 caused by an unhandled C++ exception. GDB blocked this call in order\n\ 956 to prevent the program from being terminated, and has restored the\n\ 957 context to its original state before the call.\n\ 958 To change this behaviour use \"set unwind-on-terminating-exception off\".\n\ 959 Evaluation of the expression containing the function (%s)\n\ 960 will be abandoned."), 961 name); 962 } 963 } 964 /* We hit a breakpoint inside the FUNCTION. 965 Keep the dummy frame, the user may want to examine its state. 966 Discard inferior status, we're not at the same point 967 we started at. */ 968 discard_inferior_status (inf_status); 969 970 /* The following error message used to say "The expression 971 which contained the function call has been discarded." 972 It is a hard concept to explain in a few words. Ideally, 973 GDB would be able to resume evaluation of the expression 974 when the function finally is done executing. Perhaps 975 someday this will be implemented (it would not be easy). */ 976 /* FIXME: Insert a bunch of wrap_here; name can be very long if it's 977 a C++ name with arguments and stuff. */ 978 error (_("\ 979 The program being debugged stopped while in a function called from GDB.\n\ 980 Evaluation of the expression containing the function\n\ 981 (%s) will be abandoned.\n\ 982 When the function is done executing, GDB will silently stop."), 983 name); 984 } 985 986 /* The above code errors out, so ... */ 987 internal_error (__FILE__, __LINE__, _("... should not be here")); 988 } 989 990 /* If we get here the called FUNCTION ran to completion, 991 and the dummy frame has already been popped. */ 992 993 { 994 struct regcache *retbuf = regcache_xmalloc (gdbarch); 995 struct cleanup *retbuf_cleanup = make_cleanup_regcache_xfree (retbuf); 996 struct value *retval = NULL; 997 998 regcache_cpy_no_passthrough (retbuf, stop_registers); 999 1000 /* Inferior call is successful. Restore the inferior status. 1001 At this stage, leave the RETBUF alone. */ 1002 restore_inferior_status (inf_status); 1003 1004 /* Figure out the value returned by the function. */ 1005 1006 if (lang_struct_return) 1007 retval = value_at (values_type, struct_addr); 1008 else if (TYPE_CODE (target_values_type) == TYPE_CODE_VOID) 1009 { 1010 /* If the function returns void, don't bother fetching the 1011 return value. */ 1012 retval = allocate_value (values_type); 1013 } 1014 else 1015 { 1016 switch (gdbarch_return_value (gdbarch, value_type (function), 1017 target_values_type, NULL, NULL, NULL)) 1018 { 1019 case RETURN_VALUE_REGISTER_CONVENTION: 1020 case RETURN_VALUE_ABI_RETURNS_ADDRESS: 1021 case RETURN_VALUE_ABI_PRESERVES_ADDRESS: 1022 retval = allocate_value (values_type); 1023 gdbarch_return_value (gdbarch, value_type (function), values_type, 1024 retbuf, value_contents_raw (retval), NULL); 1025 break; 1026 case RETURN_VALUE_STRUCT_CONVENTION: 1027 retval = value_at (values_type, struct_addr); 1028 break; 1029 } 1030 } 1031 1032 do_cleanups (retbuf_cleanup); 1033 1034 gdb_assert (retval); 1035 return retval; 1036 } 1037 } 1038 1039 1040 /* Provide a prototype to silence -Wmissing-prototypes. */ 1041 void _initialize_infcall (void); 1042 1043 void 1044 _initialize_infcall (void) 1045 { 1046 add_setshow_boolean_cmd ("coerce-float-to-double", class_obscure, 1047 &coerce_float_to_double_p, _("\ 1048 Set coercion of floats to doubles when calling functions."), _("\ 1049 Show coercion of floats to doubles when calling functions"), _("\ 1050 Variables of type float should generally be converted to doubles before\n\ 1051 calling an unprototyped function, and left alone when calling a prototyped\n\ 1052 function. However, some older debug info formats do not provide enough\n\ 1053 information to determine that a function is prototyped. If this flag is\n\ 1054 set, GDB will perform the conversion for a function it considers\n\ 1055 unprototyped.\n\ 1056 The default is to perform the conversion.\n"), 1057 NULL, 1058 show_coerce_float_to_double_p, 1059 &setlist, &showlist); 1060 1061 add_setshow_boolean_cmd ("unwindonsignal", no_class, 1062 &unwind_on_signal_p, _("\ 1063 Set unwinding of stack if a signal is received while in a call dummy."), _("\ 1064 Show unwinding of stack if a signal is received while in a call dummy."), _("\ 1065 The unwindonsignal lets the user determine what gdb should do if a signal\n\ 1066 is received while in a function called from gdb (call dummy). If set, gdb\n\ 1067 unwinds the stack and restore the context to what as it was before the call.\n\ 1068 The default is to stop in the frame where the signal was received."), 1069 NULL, 1070 show_unwind_on_signal_p, 1071 &setlist, &showlist); 1072 1073 add_setshow_boolean_cmd ("unwind-on-terminating-exception", no_class, 1074 &unwind_on_terminating_exception_p, _("\ 1075 Set unwinding of stack if std::terminate is called while in call dummy."), _("\ 1076 Show unwinding of stack if std::terminate() is called while in a call dummy."), _("\ 1077 The unwind on terminating exception flag lets the user determine\n\ 1078 what gdb should do if a std::terminate() call is made from the\n\ 1079 default exception handler. If set, gdb unwinds the stack and restores\n\ 1080 the context to what it was before the call. If unset, gdb allows the\n\ 1081 std::terminate call to proceed.\n\ 1082 The default is to unwind the frame."), 1083 NULL, 1084 show_unwind_on_terminating_exception_p, 1085 &setlist, &showlist); 1086 1087 } 1088