1/* Perform an inferior function call, for GDB, the GNU debugger. 2 3 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 4 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 5 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 2 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, write to the Free Software 21 Foundation, Inc., 59 Temple Place - Suite 330, 22 Boston, MA 02111-1307, USA. */ 23 24#include "defs.h" 25#include "breakpoint.h" 26#include "target.h" 27#include "regcache.h" 28#include "inferior.h" 29#include "gdb_assert.h" 30#include "block.h" 31#include "gdbcore.h" 32#include "language.h" 33#include "objfiles.h" 34#include "gdbcmd.h" 35#include "command.h" 36#include "gdb_string.h" 37#include "infcall.h" 38 39/* NOTE: cagney/2003-04-16: What's the future of this code? 40 41 GDB needs an asynchronous expression evaluator, that means an 42 asynchronous inferior function call implementation, and that in 43 turn means restructuring the code so that it is event driven. */ 44 45/* How you should pass arguments to a function depends on whether it 46 was defined in K&R style or prototype style. If you define a 47 function using the K&R syntax that takes a `float' argument, then 48 callers must pass that argument as a `double'. If you define the 49 function using the prototype syntax, then you must pass the 50 argument as a `float', with no promotion. 51 52 Unfortunately, on certain older platforms, the debug info doesn't 53 indicate reliably how each function was defined. A function type's 54 TYPE_FLAG_PROTOTYPED flag may be clear, even if the function was 55 defined in prototype style. When calling a function whose 56 TYPE_FLAG_PROTOTYPED flag is clear, GDB consults this flag to 57 decide what to do. 58 59 For modern targets, it is proper to assume that, if the prototype 60 flag is clear, that can be trusted: `float' arguments should be 61 promoted to `double'. For some older targets, if the prototype 62 flag is clear, that doesn't tell us anything. The default is to 63 trust the debug information; the user can override this behavior 64 with "set coerce-float-to-double 0". */ 65 66static int coerce_float_to_double_p = 1; 67 68/* This boolean tells what gdb should do if a signal is received while 69 in a function called from gdb (call dummy). If set, gdb unwinds 70 the stack and restore the context to what as it was before the 71 call. 72 73 The default is to stop in the frame where the signal was received. */ 74 75int unwind_on_signal_p = 0; 76 77/* Perform the standard coercions that are specified 78 for arguments to be passed to C functions. 79 80 If PARAM_TYPE is non-NULL, it is the expected parameter type. 81 IS_PROTOTYPED is non-zero if the function declaration is prototyped. */ 82 83static struct value * 84value_arg_coerce (struct value *arg, struct type *param_type, 85 int is_prototyped) 86{ 87 struct type *arg_type = check_typedef (VALUE_TYPE (arg)); 88 struct type *type 89 = param_type ? check_typedef (param_type) : arg_type; 90 91 switch (TYPE_CODE (type)) 92 { 93 case TYPE_CODE_REF: 94 if (TYPE_CODE (arg_type) != TYPE_CODE_REF 95 && TYPE_CODE (arg_type) != TYPE_CODE_PTR) 96 { 97 arg = value_addr (arg); 98 VALUE_TYPE (arg) = param_type; 99 return arg; 100 } 101 break; 102 case TYPE_CODE_INT: 103 case TYPE_CODE_CHAR: 104 case TYPE_CODE_BOOL: 105 case TYPE_CODE_ENUM: 106 /* If we don't have a prototype, coerce to integer type if necessary. */ 107 if (!is_prototyped) 108 { 109 if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int)) 110 type = builtin_type_int; 111 } 112 /* Currently all target ABIs require at least the width of an integer 113 type for an argument. We may have to conditionalize the following 114 type coercion for future targets. */ 115 if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int)) 116 type = builtin_type_int; 117 break; 118 case TYPE_CODE_FLT: 119 if (!is_prototyped && coerce_float_to_double_p) 120 { 121 if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_double)) 122 type = builtin_type_double; 123 else if (TYPE_LENGTH (type) > TYPE_LENGTH (builtin_type_double)) 124 type = builtin_type_long_double; 125 } 126 break; 127 case TYPE_CODE_FUNC: 128 type = lookup_pointer_type (type); 129 break; 130 case TYPE_CODE_ARRAY: 131 /* Arrays are coerced to pointers to their first element, unless 132 they are vectors, in which case we want to leave them alone, 133 because they are passed by value. */ 134 if (current_language->c_style_arrays) 135 if (!TYPE_VECTOR (type)) 136 type = lookup_pointer_type (TYPE_TARGET_TYPE (type)); 137 break; 138 case TYPE_CODE_UNDEF: 139 case TYPE_CODE_PTR: 140 case TYPE_CODE_STRUCT: 141 case TYPE_CODE_UNION: 142 case TYPE_CODE_VOID: 143 case TYPE_CODE_SET: 144 case TYPE_CODE_RANGE: 145 case TYPE_CODE_STRING: 146 case TYPE_CODE_BITSTRING: 147 case TYPE_CODE_ERROR: 148 case TYPE_CODE_MEMBER: 149 case TYPE_CODE_METHOD: 150 case TYPE_CODE_COMPLEX: 151 default: 152 break; 153 } 154 155 return value_cast (type, arg); 156} 157 158/* Determine a function's address and its return type from its value. 159 Calls error() if the function is not valid for calling. */ 160 161CORE_ADDR 162find_function_addr (struct value *function, struct type **retval_type) 163{ 164 struct type *ftype = check_typedef (VALUE_TYPE (function)); 165 enum type_code code = TYPE_CODE (ftype); 166 struct type *value_type; 167 CORE_ADDR funaddr; 168 169 /* If it's a member function, just look at the function 170 part of it. */ 171 172 /* Determine address to call. */ 173 if (code == TYPE_CODE_FUNC || code == TYPE_CODE_METHOD) 174 { 175 funaddr = VALUE_ADDRESS (function); 176 value_type = TYPE_TARGET_TYPE (ftype); 177 } 178 else if (code == TYPE_CODE_PTR) 179 { 180 funaddr = value_as_address (function); 181 ftype = check_typedef (TYPE_TARGET_TYPE (ftype)); 182 if (TYPE_CODE (ftype) == TYPE_CODE_FUNC 183 || TYPE_CODE (ftype) == TYPE_CODE_METHOD) 184 { 185 funaddr = gdbarch_convert_from_func_ptr_addr (current_gdbarch, 186 funaddr, 187 ¤t_target); 188 value_type = TYPE_TARGET_TYPE (ftype); 189 } 190 else 191 value_type = builtin_type_int; 192 } 193 else if (code == TYPE_CODE_INT) 194 { 195 /* Handle the case of functions lacking debugging info. 196 Their values are characters since their addresses are char */ 197 if (TYPE_LENGTH (ftype) == 1) 198 funaddr = value_as_address (value_addr (function)); 199 else 200 /* Handle integer used as address of a function. */ 201 funaddr = (CORE_ADDR) value_as_long (function); 202 203 value_type = builtin_type_int; 204 } 205 else 206 error ("Invalid data type for function to be called."); 207 208 *retval_type = value_type; 209 return funaddr; 210} 211 212/* Call breakpoint_auto_delete on the current contents of the bpstat 213 pointed to by arg (which is really a bpstat *). */ 214 215static void 216breakpoint_auto_delete_contents (void *arg) 217{ 218 breakpoint_auto_delete (*(bpstat *) arg); 219} 220 221static CORE_ADDR 222legacy_push_dummy_code (struct gdbarch *gdbarch, 223 CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc, 224 struct value **args, int nargs, 225 struct type *value_type, 226 CORE_ADDR *real_pc, CORE_ADDR *bp_addr) 227{ 228 /* CALL_DUMMY is an array of words (DEPRECATED_REGISTER_SIZE), but 229 each word is in host byte order. Before calling 230 DEPRECATED_FIX_CALL_DUMMY, we byteswap it and remove any extra 231 bytes which might exist because ULONGEST is bigger than 232 DEPRECATED_REGISTER_SIZE. */ 233 /* NOTE: This is pretty wierd, as the call dummy is actually a 234 sequence of instructions. But CISC machines will have to pack 235 the instructions into DEPRECATED_REGISTER_SIZE units (and so will 236 RISC machines for which INSTRUCTION_SIZE is not 237 DEPRECATED_REGISTER_SIZE). */ 238 /* NOTE: This is pretty stupid. CALL_DUMMY should be in strict 239 target byte order. */ 240 CORE_ADDR start_sp; 241 ULONGEST *dummy = alloca (DEPRECATED_SIZEOF_CALL_DUMMY_WORDS); 242 int sizeof_dummy1 = (DEPRECATED_REGISTER_SIZE 243 * DEPRECATED_SIZEOF_CALL_DUMMY_WORDS 244 / sizeof (ULONGEST)); 245 char *dummy1 = alloca (sizeof_dummy1); 246 memcpy (dummy, DEPRECATED_CALL_DUMMY_WORDS, 247 DEPRECATED_SIZEOF_CALL_DUMMY_WORDS); 248 if (INNER_THAN (1, 2)) 249 { 250 /* Stack grows down */ 251 sp -= sizeof_dummy1; 252 start_sp = sp; 253 } 254 else 255 { 256 /* Stack grows up */ 257 start_sp = sp; 258 sp += sizeof_dummy1; 259 } 260 /* NOTE: cagney/2002-09-10: Don't bother re-adjusting the stack 261 after allocating space for the call dummy. A target can specify 262 a SIZEOF_DUMMY1 (via DEPRECATED_SIZEOF_CALL_DUMMY_WORDS) such 263 that all local alignment requirements are met. */ 264 /* Create a call sequence customized for this function and the 265 number of arguments for it. */ 266 { 267 int i; 268 for (i = 0; i < (int) (DEPRECATED_SIZEOF_CALL_DUMMY_WORDS / sizeof (dummy[0])); 269 i++) 270 store_unsigned_integer (&dummy1[i * DEPRECATED_REGISTER_SIZE], 271 DEPRECATED_REGISTER_SIZE, 272 (ULONGEST) dummy[i]); 273 } 274 /* NOTE: cagney/2003-04-22: This computation of REAL_PC, BP_ADDR and 275 DUMMY_ADDR is pretty messed up. It comes from constant tinkering 276 with the values. Instead a DEPRECATED_FIX_CALL_DUMMY replacement 277 (PUSH_DUMMY_BREAKPOINT?) should just do everything. */ 278 if (!gdbarch_push_dummy_call_p (current_gdbarch)) 279 { 280#ifdef GDB_TARGET_IS_HPPA 281 (*real_pc) = DEPRECATED_FIX_CALL_DUMMY (dummy1, start_sp, funaddr, nargs, 282 args, value_type, using_gcc); 283#else 284 if (DEPRECATED_FIX_CALL_DUMMY_P ()) 285 { 286 /* gdb_assert (CALL_DUMMY_LOCATION == ON_STACK) true? */ 287 DEPRECATED_FIX_CALL_DUMMY (dummy1, start_sp, funaddr, nargs, args, 288 value_type, using_gcc); 289 } 290 (*real_pc) = start_sp; 291#endif 292 } 293 /* Yes, the offset is applied to the real_pc and not the dummy addr. 294 Ulgh! Blame the HP/UX target. */ 295 (*bp_addr) = (*real_pc) + DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET; 296 /* Yes, the offset is applied to the real_pc and not the 297 dummy_addr. Ulgh! Blame the HP/UX target. */ 298 (*real_pc) += DEPRECATED_CALL_DUMMY_START_OFFSET; 299 write_memory (start_sp, (char *) dummy1, sizeof_dummy1); 300 if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES) 301 generic_save_call_dummy_addr (start_sp, start_sp + sizeof_dummy1); 302 return sp; 303} 304 305static CORE_ADDR 306generic_push_dummy_code (struct gdbarch *gdbarch, 307 CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc, 308 struct value **args, int nargs, 309 struct type *value_type, 310 CORE_ADDR *real_pc, CORE_ADDR *bp_addr) 311{ 312 /* Something here to findout the size of a breakpoint and then 313 allocate space for it on the stack. */ 314 int bplen; 315 /* This code assumes frame align. */ 316 gdb_assert (gdbarch_frame_align_p (gdbarch)); 317 /* Force the stack's alignment. The intent is to ensure that the SP 318 is aligned to at least a breakpoint instruction's boundary. */ 319 sp = gdbarch_frame_align (gdbarch, sp); 320 /* Allocate space for, and then position the breakpoint on the 321 stack. */ 322 if (gdbarch_inner_than (gdbarch, 1, 2)) 323 { 324 CORE_ADDR bppc = sp; 325 gdbarch_breakpoint_from_pc (gdbarch, &bppc, &bplen); 326 sp = gdbarch_frame_align (gdbarch, sp - bplen); 327 (*bp_addr) = sp; 328 /* Should the breakpoint size/location be re-computed here? */ 329 } 330 else 331 { 332 (*bp_addr) = sp; 333 gdbarch_breakpoint_from_pc (gdbarch, bp_addr, &bplen); 334 sp = gdbarch_frame_align (gdbarch, sp + bplen); 335 } 336 /* Inferior resumes at the function entry point. */ 337 (*real_pc) = funaddr; 338 return sp; 339} 340 341/* Provide backward compatibility. Once DEPRECATED_FIX_CALL_DUMMY is 342 eliminated, this can be simplified. */ 343 344static CORE_ADDR 345push_dummy_code (struct gdbarch *gdbarch, 346 CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc, 347 struct value **args, int nargs, 348 struct type *value_type, 349 CORE_ADDR *real_pc, CORE_ADDR *bp_addr) 350{ 351 if (gdbarch_push_dummy_code_p (gdbarch)) 352 return gdbarch_push_dummy_code (gdbarch, sp, funaddr, using_gcc, 353 args, nargs, value_type, real_pc, bp_addr); 354 else if (DEPRECATED_FIX_CALL_DUMMY_P () 355 && !gdbarch_push_dummy_call_p (gdbarch)) 356 return legacy_push_dummy_code (gdbarch, sp, funaddr, using_gcc, 357 args, nargs, value_type, real_pc, bp_addr); 358 else 359 return generic_push_dummy_code (gdbarch, sp, funaddr, using_gcc, 360 args, nargs, value_type, real_pc, bp_addr); 361} 362 363/* All this stuff with a dummy frame may seem unnecessarily complicated 364 (why not just save registers in GDB?). The purpose of pushing a dummy 365 frame which looks just like a real frame is so that if you call a 366 function and then hit a breakpoint (get a signal, etc), "backtrace" 367 will look right. Whether the backtrace needs to actually show the 368 stack at the time the inferior function was called is debatable, but 369 it certainly needs to not display garbage. So if you are contemplating 370 making dummy frames be different from normal frames, consider that. */ 371 372/* Perform a function call in the inferior. 373 ARGS is a vector of values of arguments (NARGS of them). 374 FUNCTION is a value, the function to be called. 375 Returns a value representing what the function returned. 376 May fail to return, if a breakpoint or signal is hit 377 during the execution of the function. 378 379 ARGS is modified to contain coerced values. */ 380 381struct value * 382call_function_by_hand (struct value *function, int nargs, struct value **args) 383{ 384 CORE_ADDR sp; 385 CORE_ADDR dummy_addr; 386 struct type *value_type; 387 unsigned char struct_return; 388 CORE_ADDR struct_addr = 0; 389 struct regcache *retbuf; 390 struct cleanup *retbuf_cleanup; 391 struct inferior_status *inf_status; 392 struct cleanup *inf_status_cleanup; 393 CORE_ADDR funaddr; 394 int using_gcc; /* Set to version of gcc in use, or zero if not gcc */ 395 CORE_ADDR real_pc; 396 struct type *ftype = check_typedef (SYMBOL_TYPE (function)); 397 CORE_ADDR bp_addr; 398 399 if (!target_has_execution) 400 noprocess (); 401 402 /* Create a cleanup chain that contains the retbuf (buffer 403 containing the register values). This chain is create BEFORE the 404 inf_status chain so that the inferior status can cleaned up 405 (restored or discarded) without having the retbuf freed. */ 406 retbuf = regcache_xmalloc (current_gdbarch); 407 retbuf_cleanup = make_cleanup_regcache_xfree (retbuf); 408 409 /* A cleanup for the inferior status. Create this AFTER the retbuf 410 so that this can be discarded or applied without interfering with 411 the regbuf. */ 412 inf_status = save_inferior_status (1); 413 inf_status_cleanup = make_cleanup_restore_inferior_status (inf_status); 414 415 if (DEPRECATED_PUSH_DUMMY_FRAME_P ()) 416 { 417 /* DEPRECATED_PUSH_DUMMY_FRAME is responsible for saving the 418 inferior registers (and frame_pop() for restoring them). (At 419 least on most machines) they are saved on the stack in the 420 inferior. */ 421 DEPRECATED_PUSH_DUMMY_FRAME; 422 } 423 else 424 { 425 /* FIXME: cagney/2003-02-26: Step zero of this little tinker is 426 to extract the generic dummy frame code from the architecture 427 vector. Hence this direct call. 428 429 A follow-on change is to modify this interface so that it takes 430 thread OR frame OR ptid as a parameter, and returns a dummy 431 frame handle. The handle can then be used further down as a 432 parameter to generic_save_dummy_frame_tos(). Hmm, thinking 433 about it, since everything is ment to be using generic dummy 434 frames, why not even use some of the dummy frame code to here - 435 do a regcache dup and then pass the duped regcache, along with 436 all the other stuff, at one single point. 437 438 In fact, you can even save the structure's return address in the 439 dummy frame and fix one of those nasty lost struct return edge 440 conditions. */ 441 generic_push_dummy_frame (); 442 } 443 444 /* Ensure that the initial SP is correctly aligned. */ 445 { 446 CORE_ADDR old_sp = read_sp (); 447 if (gdbarch_frame_align_p (current_gdbarch)) 448 { 449 sp = gdbarch_frame_align (current_gdbarch, old_sp); 450 /* NOTE: cagney/2003-08-13: Skip the "red zone". For some 451 ABIs, a function can use memory beyond the inner most stack 452 address. AMD64 called that region the "red zone". Skip at 453 least the "red zone" size before allocating any space on 454 the stack. */ 455 if (INNER_THAN (1, 2)) 456 sp -= gdbarch_frame_red_zone_size (current_gdbarch); 457 else 458 sp += gdbarch_frame_red_zone_size (current_gdbarch); 459 /* Still aligned? */ 460 gdb_assert (sp == gdbarch_frame_align (current_gdbarch, sp)); 461 /* NOTE: cagney/2002-09-18: 462 463 On a RISC architecture, a void parameterless generic dummy 464 frame (i.e., no parameters, no result) typically does not 465 need to push anything the stack and hence can leave SP and 466 FP. Similarly, a frameless (possibly leaf) function does 467 not push anything on the stack and, hence, that too can 468 leave FP and SP unchanged. As a consequence, a sequence of 469 void parameterless generic dummy frame calls to frameless 470 functions will create a sequence of effectively identical 471 frames (SP, FP and TOS and PC the same). This, not 472 suprisingly, results in what appears to be a stack in an 473 infinite loop --- when GDB tries to find a generic dummy 474 frame on the internal dummy frame stack, it will always 475 find the first one. 476 477 To avoid this problem, the code below always grows the 478 stack. That way, two dummy frames can never be identical. 479 It does burn a few bytes of stack but that is a small price 480 to pay :-). */ 481 if (sp == old_sp) 482 { 483 if (INNER_THAN (1, 2)) 484 /* Stack grows down. */ 485 sp = gdbarch_frame_align (current_gdbarch, old_sp - 1); 486 else 487 /* Stack grows up. */ 488 sp = gdbarch_frame_align (current_gdbarch, old_sp + 1); 489 } 490 gdb_assert ((INNER_THAN (1, 2) && sp <= old_sp) 491 || (INNER_THAN (2, 1) && sp >= old_sp)); 492 } 493 else 494 /* FIXME: cagney/2002-09-18: Hey, you loose! 495 496 Who knows how badly aligned the SP is! 497 498 If the generic dummy frame ends up empty (because nothing is 499 pushed) GDB won't be able to correctly perform back traces. 500 If a target is having trouble with backtraces, first thing to 501 do is add FRAME_ALIGN() to the architecture vector. If that 502 fails, try unwind_dummy_id(). 503 504 If the ABI specifies a "Red Zone" (see the doco) the code 505 below will quietly trash it. */ 506 sp = old_sp; 507 } 508 509 funaddr = find_function_addr (function, &value_type); 510 CHECK_TYPEDEF (value_type); 511 512 { 513 struct block *b = block_for_pc (funaddr); 514 /* If compiled without -g, assume GCC 2. */ 515 using_gcc = (b == NULL ? 2 : BLOCK_GCC_COMPILED (b)); 516 } 517 518 /* Are we returning a value using a structure return or a normal 519 value return? */ 520 521 struct_return = using_struct_return (value_type, using_gcc); 522 523 /* Determine the location of the breakpoint (and possibly other 524 stuff) that the called function will return to. The SPARC, for a 525 function returning a structure or union, needs to make space for 526 not just the breakpoint but also an extra word containing the 527 size (?) of the structure being passed. */ 528 529 /* The actual breakpoint (at BP_ADDR) is inserted separatly so there 530 is no need to write that out. */ 531 532 switch (CALL_DUMMY_LOCATION) 533 { 534 case ON_STACK: 535 /* "dummy_addr" is here just to keep old targets happy. New 536 targets return that same information via "sp" and "bp_addr". */ 537 if (INNER_THAN (1, 2)) 538 { 539 sp = push_dummy_code (current_gdbarch, sp, funaddr, 540 using_gcc, args, nargs, value_type, 541 &real_pc, &bp_addr); 542 dummy_addr = sp; 543 } 544 else 545 { 546 dummy_addr = sp; 547 sp = push_dummy_code (current_gdbarch, sp, funaddr, 548 using_gcc, args, nargs, value_type, 549 &real_pc, &bp_addr); 550 } 551 break; 552 case AT_ENTRY_POINT: 553 if (DEPRECATED_FIX_CALL_DUMMY_P () 554 && !gdbarch_push_dummy_call_p (current_gdbarch)) 555 { 556 /* Sigh. Some targets use DEPRECATED_FIX_CALL_DUMMY to 557 shove extra stuff onto the stack or into registers. That 558 code should be in PUSH_DUMMY_CALL, however, in the mean 559 time ... */ 560 /* If the target is manipulating DUMMY1, it looses big time. */ 561 void *dummy1 = NULL; 562 DEPRECATED_FIX_CALL_DUMMY (dummy1, sp, funaddr, nargs, args, 563 value_type, using_gcc); 564 } 565 real_pc = funaddr; 566 dummy_addr = entry_point_address (); 567 /* Make certain that the address points at real code, and not a 568 function descriptor. */ 569 dummy_addr = gdbarch_convert_from_func_ptr_addr (current_gdbarch, 570 dummy_addr, 571 ¤t_target); 572 /* A call dummy always consists of just a single breakpoint, so 573 it's address is the same as the address of the dummy. */ 574 bp_addr = dummy_addr; 575 break; 576 case AT_SYMBOL: 577 /* Some executables define a symbol __CALL_DUMMY_ADDRESS whose 578 address is the location where the breakpoint should be 579 placed. Once all targets are using the overhauled frame code 580 this can be deleted - ON_STACK is a better option. */ 581 { 582 struct minimal_symbol *sym; 583 584 sym = lookup_minimal_symbol ("__CALL_DUMMY_ADDRESS", NULL, NULL); 585 real_pc = funaddr; 586 if (sym) 587 dummy_addr = SYMBOL_VALUE_ADDRESS (sym); 588 else 589 dummy_addr = entry_point_address (); 590 /* Make certain that the address points at real code, and not 591 a function descriptor. */ 592 dummy_addr = gdbarch_convert_from_func_ptr_addr (current_gdbarch, 593 dummy_addr, 594 ¤t_target); 595 /* A call dummy always consists of just a single breakpoint, 596 so it's address is the same as the address of the dummy. */ 597 bp_addr = dummy_addr; 598 break; 599 } 600 default: 601 internal_error (__FILE__, __LINE__, "bad switch"); 602 } 603 604 if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES) 605 /* Save where the breakpoint is going to be inserted so that the 606 dummy-frame code is later able to re-identify it. */ 607 generic_save_call_dummy_addr (bp_addr, bp_addr + 1); 608 609 if (nargs < TYPE_NFIELDS (ftype)) 610 error ("too few arguments in function call"); 611 612 { 613 int i; 614 for (i = nargs - 1; i >= 0; i--) 615 { 616 int prototyped; 617 struct type *param_type; 618 619 /* FIXME drow/2002-05-31: Should just always mark methods as 620 prototyped. Can we respect TYPE_VARARGS? Probably not. */ 621 if (TYPE_CODE (ftype) == TYPE_CODE_METHOD) 622 prototyped = 1; 623 else if (i < TYPE_NFIELDS (ftype)) 624 prototyped = TYPE_PROTOTYPED (ftype); 625 else 626 prototyped = 0; 627 628 if (i < TYPE_NFIELDS (ftype)) 629 param_type = TYPE_FIELD_TYPE (ftype, i); 630 else 631 param_type = NULL; 632 633 args[i] = value_arg_coerce (args[i], param_type, prototyped); 634 635 /* elz: this code is to handle the case in which the function 636 to be called has a pointer to function as parameter and the 637 corresponding actual argument is the address of a function 638 and not a pointer to function variable. In aCC compiled 639 code, the calls through pointers to functions (in the body 640 of the function called by hand) are made via 641 $$dyncall_external which requires some registers setting, 642 this is taken care of if we call via a function pointer 643 variable, but not via a function address. In cc this is 644 not a problem. */ 645 646 if (using_gcc == 0) 647 { 648 if (param_type != NULL && TYPE_CODE (ftype) != TYPE_CODE_METHOD) 649 { 650 /* if this parameter is a pointer to function. */ 651 if (TYPE_CODE (param_type) == TYPE_CODE_PTR) 652 if (TYPE_CODE (TYPE_TARGET_TYPE (param_type)) == TYPE_CODE_FUNC) 653 /* elz: FIXME here should go the test about the 654 compiler used to compile the target. We want to 655 issue the error message only if the compiler 656 used was HP's aCC. If we used HP's cc, then 657 there is no problem and no need to return at 658 this point. */ 659 /* Go see if the actual parameter is a variable of 660 type pointer to function or just a function. */ 661 if (args[i]->lval == not_lval) 662 { 663 char *arg_name; 664 if (find_pc_partial_function ((CORE_ADDR) args[i]->aligner.contents[0], &arg_name, NULL, NULL)) 665 error ("\ 666You cannot use function <%s> as argument. \n\ 667You must use a pointer to function type variable. Command ignored.", arg_name); 668 } 669 } 670 } 671 } 672 } 673 674 if (DEPRECATED_REG_STRUCT_HAS_ADDR_P ()) 675 { 676 int i; 677 /* This is a machine like the sparc, where we may need to pass a 678 pointer to the structure, not the structure itself. */ 679 for (i = nargs - 1; i >= 0; i--) 680 { 681 struct type *arg_type = check_typedef (VALUE_TYPE (args[i])); 682 if ((TYPE_CODE (arg_type) == TYPE_CODE_STRUCT 683 || TYPE_CODE (arg_type) == TYPE_CODE_UNION 684 || TYPE_CODE (arg_type) == TYPE_CODE_ARRAY 685 || TYPE_CODE (arg_type) == TYPE_CODE_STRING 686 || TYPE_CODE (arg_type) == TYPE_CODE_BITSTRING 687 || TYPE_CODE (arg_type) == TYPE_CODE_SET 688 || (TYPE_CODE (arg_type) == TYPE_CODE_FLT 689 && TYPE_LENGTH (arg_type) > 8) 690 ) 691 && DEPRECATED_REG_STRUCT_HAS_ADDR (using_gcc, arg_type)) 692 { 693 CORE_ADDR addr; 694 int len; /* = TYPE_LENGTH (arg_type); */ 695 int aligned_len; 696 arg_type = check_typedef (VALUE_ENCLOSING_TYPE (args[i])); 697 len = TYPE_LENGTH (arg_type); 698 699 if (DEPRECATED_STACK_ALIGN_P ()) 700 /* MVS 11/22/96: I think at least some of this 701 stack_align code is really broken. Better to let 702 PUSH_ARGUMENTS adjust the stack in a target-defined 703 manner. */ 704 aligned_len = DEPRECATED_STACK_ALIGN (len); 705 else 706 aligned_len = len; 707 if (INNER_THAN (1, 2)) 708 { 709 /* stack grows downward */ 710 sp -= aligned_len; 711 /* ... so the address of the thing we push is the 712 stack pointer after we push it. */ 713 addr = sp; 714 } 715 else 716 { 717 /* The stack grows up, so the address of the thing 718 we push is the stack pointer before we push it. */ 719 addr = sp; 720 sp += aligned_len; 721 } 722 /* Push the structure. */ 723 write_memory (addr, VALUE_CONTENTS_ALL (args[i]), len); 724 /* The value we're going to pass is the address of the 725 thing we just pushed. */ 726 /*args[i] = value_from_longest (lookup_pointer_type (value_type), 727 (LONGEST) addr); */ 728 args[i] = value_from_pointer (lookup_pointer_type (arg_type), 729 addr); 730 } 731 } 732 } 733 734 735 /* Reserve space for the return structure to be written on the 736 stack, if necessary. Make certain that the value is correctly 737 aligned. */ 738 739 if (struct_return) 740 { 741 int len = TYPE_LENGTH (value_type); 742 if (DEPRECATED_STACK_ALIGN_P ()) 743 /* NOTE: cagney/2003-03-22: Should rely on frame align, rather 744 than stack align to force the alignment of the stack. */ 745 len = DEPRECATED_STACK_ALIGN (len); 746 if (INNER_THAN (1, 2)) 747 { 748 /* Stack grows downward. Align STRUCT_ADDR and SP after 749 making space for the return value. */ 750 sp -= len; 751 if (gdbarch_frame_align_p (current_gdbarch)) 752 sp = gdbarch_frame_align (current_gdbarch, sp); 753 struct_addr = sp; 754 } 755 else 756 { 757 /* Stack grows upward. Align the frame, allocate space, and 758 then again, re-align the frame??? */ 759 if (gdbarch_frame_align_p (current_gdbarch)) 760 sp = gdbarch_frame_align (current_gdbarch, sp); 761 struct_addr = sp; 762 sp += len; 763 if (gdbarch_frame_align_p (current_gdbarch)) 764 sp = gdbarch_frame_align (current_gdbarch, sp); 765 } 766 } 767 768 /* Create the dummy stack frame. Pass in the call dummy address as, 769 presumably, the ABI code knows where, in the call dummy, the 770 return address should be pointed. */ 771 if (gdbarch_push_dummy_call_p (current_gdbarch)) 772 /* When there is no push_dummy_call method, should this code 773 simply error out. That would the implementation of this method 774 for all ABIs (which is probably a good thing). */ 775 sp = gdbarch_push_dummy_call (current_gdbarch, funaddr, current_regcache, 776 bp_addr, nargs, args, sp, struct_return, 777 struct_addr); 778 else if (DEPRECATED_PUSH_ARGUMENTS_P ()) 779 /* Keep old targets working. */ 780 sp = DEPRECATED_PUSH_ARGUMENTS (nargs, args, sp, struct_return, 781 struct_addr); 782 else 783 sp = legacy_push_arguments (nargs, args, sp, struct_return, struct_addr); 784 785 if (DEPRECATED_PUSH_RETURN_ADDRESS_P ()) 786 /* for targets that use no CALL_DUMMY */ 787 /* There are a number of targets now which actually don't write 788 any CALL_DUMMY instructions into the target, but instead just 789 save the machine state, push the arguments, and jump directly 790 to the callee function. Since this doesn't actually involve 791 executing a JSR/BSR instruction, the return address must be set 792 up by hand, either by pushing onto the stack or copying into a 793 return-address register as appropriate. Formerly this has been 794 done in PUSH_ARGUMENTS, but that's overloading its 795 functionality a bit, so I'm making it explicit to do it here. */ 796 /* NOTE: cagney/2003-04-22: The first parameter ("real_pc") has 797 been replaced with zero, it turns out that no implementation 798 used that parameter. This occured because the value being 799 supplied - the address of the called function's entry point 800 instead of the address of the breakpoint that the called 801 function should return to - wasn't useful. */ 802 sp = DEPRECATED_PUSH_RETURN_ADDRESS (0, sp); 803 804 /* NOTE: cagney/2003-03-23: Diable this code when there is a 805 push_dummy_call() method. Since that method will have already 806 handled any alignment issues, the code below is entirely 807 redundant. */ 808 if (!gdbarch_push_dummy_call_p (current_gdbarch) 809 && DEPRECATED_STACK_ALIGN_P () && !INNER_THAN (1, 2)) 810 { 811 /* If stack grows up, we must leave a hole at the bottom, note 812 that sp already has been advanced for the arguments! */ 813 sp = DEPRECATED_STACK_ALIGN (sp); 814 } 815 816 /* Store the address at which the structure is supposed to be 817 written. */ 818 /* NOTE: 2003-03-24: Since PUSH_ARGUMENTS can (and typically does) 819 store the struct return address, this call is entirely redundant. */ 820 if (struct_return && DEPRECATED_STORE_STRUCT_RETURN_P ()) 821 DEPRECATED_STORE_STRUCT_RETURN (struct_addr, sp); 822 823 /* Write the stack pointer. This is here because the statements 824 above might fool with it. On SPARC, this write also stores the 825 register window into the right place in the new stack frame, 826 which otherwise wouldn't happen (see store_inferior_registers in 827 sparc-nat.c). */ 828 /* NOTE: cagney/2003-03-23: Since the architecture method 829 push_dummy_call() should have already stored the stack pointer 830 (as part of creating the fake call frame), and none of the code 831 following that call adjusts the stack-pointer value, the below 832 call is entirely redundant. */ 833 if (DEPRECATED_DUMMY_WRITE_SP_P ()) 834 DEPRECATED_DUMMY_WRITE_SP (sp); 835 836 if (gdbarch_unwind_dummy_id_p (current_gdbarch)) 837 { 838 /* Sanity. The exact same SP value is returned by 839 PUSH_DUMMY_CALL, saved as the dummy-frame TOS, and used by 840 unwind_dummy_id to form the frame ID's stack address. */ 841 gdb_assert (DEPRECATED_USE_GENERIC_DUMMY_FRAMES); 842 generic_save_dummy_frame_tos (sp); 843 } 844 else if (DEPRECATED_SAVE_DUMMY_FRAME_TOS_P ()) 845 DEPRECATED_SAVE_DUMMY_FRAME_TOS (sp); 846 847 /* Now proceed, having reached the desired place. */ 848 clear_proceed_status (); 849 850 /* Create a momentary breakpoint at the return address of the 851 inferior. That way it breaks when it returns. */ 852 853 { 854 struct breakpoint *bpt; 855 struct symtab_and_line sal; 856 struct frame_id frame; 857 init_sal (&sal); /* initialize to zeroes */ 858 sal.pc = bp_addr; 859 sal.section = find_pc_overlay (sal.pc); 860 /* Set up a frame ID for the dummy frame so we can pass it to 861 set_momentary_breakpoint. We need to give the breakpoint a 862 frame ID so that the breakpoint code can correctly re-identify 863 the dummy breakpoint. */ 864 if (gdbarch_unwind_dummy_id_p (current_gdbarch)) 865 { 866 /* Sanity. The exact same SP value is returned by 867 PUSH_DUMMY_CALL, saved as the dummy-frame TOS, and used by 868 unwind_dummy_id to form the frame ID's stack address. */ 869 gdb_assert (DEPRECATED_USE_GENERIC_DUMMY_FRAMES); 870 frame = frame_id_build (sp, sal.pc); 871 } 872 else 873 { 874 /* The assumption here is that push_dummy_call() returned the 875 stack part of the frame ID. Unfortunately, many older 876 architectures were, via a convoluted mess, relying on the 877 poorly defined and greatly overloaded 878 DEPRECATED_TARGET_READ_FP or DEPRECATED_FP_REGNUM to supply 879 the value. */ 880 if (DEPRECATED_TARGET_READ_FP_P ()) 881 frame = frame_id_build (DEPRECATED_TARGET_READ_FP (), sal.pc); 882 else if (DEPRECATED_FP_REGNUM >= 0) 883 frame = frame_id_build (read_register (DEPRECATED_FP_REGNUM), sal.pc); 884 else 885 frame = frame_id_build (sp, sal.pc); 886 } 887 bpt = set_momentary_breakpoint (sal, frame, bp_call_dummy); 888 bpt->disposition = disp_del; 889 } 890 891 /* Execute a "stack dummy", a piece of code stored in the stack by 892 the debugger to be executed in the inferior. 893 894 The dummy's frame is automatically popped whenever that break is 895 hit. If that is the first time the program stops, 896 call_function_by_hand returns to its caller with that frame 897 already gone and sets RC to 0. 898 899 Otherwise, set RC to a non-zero value. If the called function 900 receives a random signal, we do not allow the user to continue 901 executing it as this may not work. The dummy frame is poped and 902 we return 1. If we hit a breakpoint, we leave the frame in place 903 and return 2 (the frame will eventually be popped when we do hit 904 the dummy end breakpoint). */ 905 906 { 907 struct cleanup *old_cleanups = make_cleanup (null_cleanup, 0); 908 int saved_async = 0; 909 910 /* If all error()s out of proceed ended up calling normal_stop 911 (and perhaps they should; it already does in the special case 912 of error out of resume()), then we wouldn't need this. */ 913 make_cleanup (breakpoint_auto_delete_contents, &stop_bpstat); 914 915 disable_watchpoints_before_interactive_call_start (); 916 proceed_to_finish = 1; /* We want stop_registers, please... */ 917 918 if (target_can_async_p ()) 919 saved_async = target_async_mask (0); 920 921 proceed (real_pc, TARGET_SIGNAL_0, 0); 922 923 if (saved_async) 924 target_async_mask (saved_async); 925 926 enable_watchpoints_after_interactive_call_stop (); 927 928 discard_cleanups (old_cleanups); 929 } 930 931 if (stopped_by_random_signal || !stop_stack_dummy) 932 { 933 /* Find the name of the function we're about to complain about. */ 934 const char *name = NULL; 935 { 936 struct symbol *symbol = find_pc_function (funaddr); 937 if (symbol) 938 name = SYMBOL_PRINT_NAME (symbol); 939 else 940 { 941 /* Try the minimal symbols. */ 942 struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (funaddr); 943 if (msymbol) 944 name = SYMBOL_PRINT_NAME (msymbol); 945 } 946 if (name == NULL) 947 { 948 /* Can't use a cleanup here. It is discarded, instead use 949 an alloca. */ 950 char *tmp = xstrprintf ("at %s", local_hex_string (funaddr)); 951 char *a = alloca (strlen (tmp) + 1); 952 strcpy (a, tmp); 953 xfree (tmp); 954 name = a; 955 } 956 } 957 if (stopped_by_random_signal) 958 { 959 /* We stopped inside the FUNCTION because of a random 960 signal. Further execution of the FUNCTION is not 961 allowed. */ 962 963 if (unwind_on_signal_p) 964 { 965 /* The user wants the context restored. */ 966 967 /* We must get back to the frame we were before the 968 dummy call. */ 969 frame_pop (get_current_frame ()); 970 971 /* FIXME: Insert a bunch of wrap_here; name can be very 972 long if it's a C++ name with arguments and stuff. */ 973 error ("\ 974The program being debugged was signaled while in a function called from GDB.\n\ 975GDB has restored the context to what it was before the call.\n\ 976To change this behavior use \"set unwindonsignal off\"\n\ 977Evaluation of the expression containing the function (%s) will be abandoned.", 978 name); 979 } 980 else 981 { 982 /* The user wants to stay in the frame where we stopped 983 (default).*/ 984 /* If we restored the inferior status (via the cleanup), 985 we would print a spurious error message (Unable to 986 restore previously selected frame), would write the 987 registers from the inf_status (which is wrong), and 988 would do other wrong things. */ 989 discard_cleanups (inf_status_cleanup); 990 discard_inferior_status (inf_status); 991 /* FIXME: Insert a bunch of wrap_here; name can be very 992 long if it's a C++ name with arguments and stuff. */ 993 error ("\ 994The program being debugged was signaled while in a function called from GDB.\n\ 995GDB remains in the frame where the signal was received.\n\ 996To change this behavior use \"set unwindonsignal on\"\n\ 997Evaluation of the expression containing the function (%s) will be abandoned.", 998 name); 999 } 1000 } 1001 1002 if (!stop_stack_dummy) 1003 { 1004 /* We hit a breakpoint inside the FUNCTION. */ 1005 /* If we restored the inferior status (via the cleanup), we 1006 would print a spurious error message (Unable to restore 1007 previously selected frame), would write the registers 1008 from the inf_status (which is wrong), and would do other 1009 wrong things. */ 1010 discard_cleanups (inf_status_cleanup); 1011 discard_inferior_status (inf_status); 1012 /* The following error message used to say "The expression 1013 which contained the function call has been discarded." 1014 It is a hard concept to explain in a few words. Ideally, 1015 GDB would be able to resume evaluation of the expression 1016 when the function finally is done executing. Perhaps 1017 someday this will be implemented (it would not be easy). */ 1018 /* FIXME: Insert a bunch of wrap_here; name can be very long if it's 1019 a C++ name with arguments and stuff. */ 1020 error ("\ 1021The program being debugged stopped while in a function called from GDB.\n\ 1022When the function (%s) is done executing, GDB will silently\n\ 1023stop (instead of continuing to evaluate the expression containing\n\ 1024the function call).", name); 1025 } 1026 1027 /* The above code errors out, so ... */ 1028 internal_error (__FILE__, __LINE__, "... should not be here"); 1029 } 1030 1031 /* If we get here the called FUNCTION run to completion. */ 1032 1033 /* On normal return, the stack dummy has been popped already. */ 1034 regcache_cpy_no_passthrough (retbuf, stop_registers); 1035 1036 /* Restore the inferior status, via its cleanup. At this stage, 1037 leave the RETBUF alone. */ 1038 do_cleanups (inf_status_cleanup); 1039 1040 /* Figure out the value returned by the function. */ 1041 if (struct_return) 1042 { 1043 /* NOTE: cagney/2003-09-27: This assumes that PUSH_DUMMY_CALL 1044 has correctly stored STRUCT_ADDR in the target. In the past 1045 that hasn't been the case, the old MIPS PUSH_ARGUMENTS 1046 (PUSH_DUMMY_CALL precursor) would silently move the location 1047 of the struct return value making STRUCT_ADDR bogus. If 1048 you're seeing problems with values being returned using the 1049 "struct return convention", check that PUSH_DUMMY_CALL isn't 1050 playing tricks. */ 1051 struct value *retval = value_at (value_type, struct_addr, NULL); 1052 do_cleanups (retbuf_cleanup); 1053 return retval; 1054 } 1055 else 1056 { 1057 /* The non-register case was handled above. */ 1058 struct value *retval = register_value_being_returned (value_type, 1059 retbuf); 1060 do_cleanups (retbuf_cleanup); 1061 return retval; 1062 } 1063} 1064 1065void _initialize_infcall (void); 1066 1067void 1068_initialize_infcall (void) 1069{ 1070 add_setshow_boolean_cmd ("coerce-float-to-double", class_obscure, 1071 &coerce_float_to_double_p, "\ 1072Set coercion of floats to doubles when calling functions\n\ 1073Variables of type float should generally be converted to doubles before\n\ 1074calling an unprototyped function, and left alone when calling a prototyped\n\ 1075function. However, some older debug info formats do not provide enough\n\ 1076information to determine that a function is prototyped. If this flag is\n\ 1077set, GDB will perform the conversion for a function it considers\n\ 1078unprototyped.\n\ 1079The default is to perform the conversion.\n", "\ 1080Show coercion of floats to doubles when calling functions\n\ 1081Variables of type float should generally be converted to doubles before\n\ 1082calling an unprototyped function, and left alone when calling a prototyped\n\ 1083function. However, some older debug info formats do not provide enough\n\ 1084information to determine that a function is prototyped. If this flag is\n\ 1085set, GDB will perform the conversion for a function it considers\n\ 1086unprototyped.\n\ 1087The default is to perform the conversion.\n", 1088 NULL, NULL, &setlist, &showlist); 1089 1090 add_setshow_boolean_cmd ("unwindonsignal", no_class, 1091 &unwind_on_signal_p, "\ 1092Set unwinding of stack if a signal is received while in a call dummy.\n\ 1093The unwindonsignal lets the user determine what gdb should do if a signal\n\ 1094is received while in a function called from gdb (call dummy). If set, gdb\n\ 1095unwinds the stack and restore the context to what as it was before the call.\n\ 1096The default is to stop in the frame where the signal was received.", "\ 1097Set unwinding of stack if a signal is received while in a call dummy.\n\ 1098The unwindonsignal lets the user determine what gdb should do if a signal\n\ 1099is received while in a function called from gdb (call dummy). If set, gdb\n\ 1100unwinds the stack and restore the context to what as it was before the call.\n\ 1101The default is to stop in the frame where the signal was received.", 1102 NULL, NULL, &setlist, &showlist); 1103} 1104