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