X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fdummy-frame.c;h=2fe578ee6bfdb18f9f7b61e6146890a31731ac8c;hb=cd9629e1df1a280c19e1daaf6c1195afbab0aca9;hp=bf4a31c1ef426e3abcefd810e50622fcd0fb8f4f;hpb=7a25a7c1cc419c2f4106843387e0c8be92471523;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/dummy-frame.c b/gdb/dummy-frame.c index bf4a31c1ef..2fe578ee6b 100644 --- a/gdb/dummy-frame.c +++ b/gdb/dummy-frame.c @@ -1,14 +1,12 @@ /* Code dealing with dummy stack frames, for GDB, the GNU debugger. - Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, - 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002 Free Software - Foundation, Inc. + Copyright (C) 1986-2020 Free Software Foundation, Inc. This file is part of GDB. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, or + the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, @@ -17,9 +15,7 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ + along with this program. If not, see . */ #include "defs.h" @@ -27,8 +23,46 @@ #include "regcache.h" #include "frame.h" #include "inferior.h" -#include "gdb_assert.h" #include "frame-unwind.h" +#include "command.h" +#include "gdbcmd.h" +#include "observable.h" +#include "gdbthread.h" +#include "infcall.h" +#include "gdbarch.h" + +struct dummy_frame_id +{ + /* This frame's ID. Must match the value returned by + gdbarch_dummy_id. */ + struct frame_id id; + + /* The thread this dummy_frame relates to. */ + thread_info *thread; +}; + +/* Return whether dummy_frame_id *ID1 and *ID2 are equal. */ + +static int +dummy_frame_id_eq (struct dummy_frame_id *id1, + struct dummy_frame_id *id2) +{ + return frame_id_eq (id1->id, id2->id) && id1->thread == id2->thread; +} + +/* List of dummy_frame destructors. */ + +struct dummy_frame_dtor_list +{ + /* Next element in the list or NULL if this is the last element. */ + struct dummy_frame_dtor_list *next; + + /* If non-NULL, a destructor that is run when this dummy frame is freed. */ + dummy_frame_dtor_ftype *dtor; + + /* Arbitrary data that is passed to DTOR. */ + void *dtor_data; +}; /* Dummy frame. This saves the processor state just prior to setting up the inferior function call. Older targets save the registers @@ -38,338 +72,371 @@ struct dummy_frame { struct dummy_frame *next; - /* These values belong to the caller (the previous frame, the frame - that this unwinds back to). */ - CORE_ADDR pc; - CORE_ADDR fp; - CORE_ADDR sp; - CORE_ADDR top; - struct frame_id id; - struct regcache *regcache; + /* An id represents a dummy frame. */ + struct dummy_frame_id id; + + /* The caller's state prior to the call. */ + struct infcall_suspend_state *caller_state; - /* Address range of the call dummy code. Look for PC in the range - [LO..HI) (after allowing for DECR_PC_AFTER_BREAK). */ - CORE_ADDR call_lo; - CORE_ADDR call_hi; + /* First element of destructors list or NULL if there are no + destructors registered for this dummy_frame. */ + struct dummy_frame_dtor_list *dtor_list; }; static struct dummy_frame *dummy_frame_stack = NULL; -/* Function: find_dummy_frame(pc, fp, sp) +/* Push the caller's state, along with the dummy frame info, onto the + dummy-frame stack. */ + +void +dummy_frame_push (struct infcall_suspend_state *caller_state, + const frame_id *dummy_id, thread_info *thread) +{ + struct dummy_frame *dummy_frame; + + dummy_frame = XCNEW (struct dummy_frame); + dummy_frame->caller_state = caller_state; + dummy_frame->id.id = (*dummy_id); + dummy_frame->id.thread = thread; + dummy_frame->next = dummy_frame_stack; + dummy_frame_stack = dummy_frame; +} - Search the stack of dummy frames for one matching the given PC and - FP/SP. Unlike pc_in_dummy_frame(), this function doesn't need to - adjust for DECR_PC_AFTER_BREAK. This is because it is only legal - to call this function after the PC has been adjusted. */ +/* Remove *DUMMY_PTR from the dummy frame stack. */ -static struct dummy_frame * -find_dummy_frame (CORE_ADDR pc, CORE_ADDR fp) +static void +remove_dummy_frame (struct dummy_frame **dummy_ptr) { - struct dummy_frame *dummyframe; + struct dummy_frame *dummy = *dummy_ptr; - for (dummyframe = dummy_frame_stack; dummyframe != NULL; - dummyframe = dummyframe->next) + while (dummy->dtor_list != NULL) { - /* Does the PC fall within the dummy frame's breakpoint - instruction. If not, discard this one. */ - if (!(pc >= dummyframe->call_lo && pc < dummyframe->call_hi)) - continue; - /* Does the FP match? */ - if (dummyframe->top != 0) - { - /* If the target architecture explicitly saved the - top-of-stack before the inferior function call, assume - that that same architecture will always pass in an FP - (frame base) value that eactly matches that saved TOS. - Don't check the saved SP and SP as they can lead to false - hits. */ - if (fp != dummyframe->top) - continue; - } - else - { - /* An older target that hasn't explicitly or implicitly - saved the dummy frame's top-of-stack. Try matching the - FP against the saved SP and FP. NOTE: If you're trying - to fix a problem with GDB not correctly finding a dummy - frame, check the comments that go with FRAME_ALIGN() and - SAVE_DUMMY_FRAME_TOS(). */ - if (fp != dummyframe->fp && fp != dummyframe->sp) - continue; - } - /* The FP matches this dummy frame. */ - return dummyframe; - } + struct dummy_frame_dtor_list *list = dummy->dtor_list; - return NULL; -} + dummy->dtor_list = list->next; + list->dtor (list->dtor_data, 0); + xfree (list); + } -struct dummy_frame * -cached_find_dummy_frame (struct frame_info *frame, void **cache) -{ - if ((*cache) == NULL) - (*cache) = find_dummy_frame (get_frame_pc (frame), get_frame_base (frame)); - return (*cache); + *dummy_ptr = dummy->next; + discard_infcall_suspend_state (dummy->caller_state); + xfree (dummy); } -struct regcache * -generic_find_dummy_frame (CORE_ADDR pc, CORE_ADDR fp) -{ - struct dummy_frame *dummy = find_dummy_frame (pc, fp); - if (dummy != NULL) - return dummy->regcache; - else - return NULL; -} +/* Delete any breakpoint B which is a momentary breakpoint for return from + inferior call matching DUMMY_VOIDP. */ -char * -deprecated_generic_find_dummy_frame (CORE_ADDR pc, CORE_ADDR fp) +static bool +pop_dummy_frame_bpt (struct breakpoint *b, struct dummy_frame *dummy) { - struct regcache *regcache = generic_find_dummy_frame (pc, fp); - if (regcache == NULL) - return NULL; - return deprecated_grub_regcache_for_registers (regcache); -} + if (b->thread == dummy->id.thread->global_num + && b->disposition == disp_del && frame_id_eq (b->frame_id, dummy->id.id)) + { + while (b->related_breakpoint != b) + delete_breakpoint (b->related_breakpoint); -/* Function: pc_in_call_dummy (pc, sp, fp) + delete_breakpoint (b); - Return true if the PC falls in a dummy frame created by gdb for an - inferior call. The code below which allows DECR_PC_AFTER_BREAK is - for infrun.c, which may give the function a PC without that - subtracted out. */ + /* Stop the traversal. */ + return true; + } -int -generic_pc_in_call_dummy (CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR fp) -{ - return pc_in_dummy_frame (pc); + /* Continue the traversal. */ + return false; } -/* Return non-zero if the PC falls in a dummy frame. +/* Pop *DUMMY_PTR, restoring program state to that before the + frame was created. */ - The code below which allows DECR_PC_AFTER_BREAK is for infrun.c, - which may give the function a PC without that subtracted out. +static void +pop_dummy_frame (struct dummy_frame **dummy_ptr) +{ + struct dummy_frame *dummy = *dummy_ptr; - FIXME: cagney/2002-11-23: This is silly. Surely "infrun.c" can - figure out what the real PC (as in the resume address) is BEFORE - calling this function (Oh, and I'm not even sure that this function - is called with an decremented PC, the call to pc_in_call_dummy() in - that file is conditional on !CALL_DUMMY_BREAKPOINT_OFFSET_P yet - generic dummy targets set CALL_DUMMY_BREAKPOINT_OFFSET. True?). */ + gdb_assert (dummy->id.thread == inferior_thread ()); -int -pc_in_dummy_frame (CORE_ADDR pc) -{ - struct dummy_frame *dummyframe; - for (dummyframe = dummy_frame_stack; - dummyframe != NULL; - dummyframe = dummyframe->next) + while (dummy->dtor_list != NULL) { - if ((pc >= dummyframe->call_lo) - && (pc < dummyframe->call_hi + DECR_PC_AFTER_BREAK)) - return 1; + struct dummy_frame_dtor_list *list = dummy->dtor_list; + + dummy->dtor_list = list->next; + list->dtor (list->dtor_data, 1); + xfree (list); } - return 0; + + restore_infcall_suspend_state (dummy->caller_state); + + iterate_over_breakpoints ([dummy] (breakpoint* bp) + { + return pop_dummy_frame_bpt (bp, dummy); + }); + + /* restore_infcall_control_state frees inf_state, + all that remains is to pop *dummy_ptr. */ + *dummy_ptr = dummy->next; + xfree (dummy); + + /* We've made right mess of GDB's local state, just discard + everything. */ + reinit_frame_cache (); } -/* Function: read_register_dummy - Find a saved register from before GDB calls a function in the inferior */ +/* Look up DUMMY_ID. + Return NULL if not found. */ -CORE_ADDR -deprecated_read_register_dummy (CORE_ADDR pc, CORE_ADDR fp, int regno) +static struct dummy_frame ** +lookup_dummy_frame (struct dummy_frame_id *dummy_id) { - struct regcache *dummy_regs = generic_find_dummy_frame (pc, fp); + struct dummy_frame **dp; - if (dummy_regs) + for (dp = &dummy_frame_stack; *dp != NULL; dp = &(*dp)->next) { - /* NOTE: cagney/2002-08-12: Replaced a call to - regcache_raw_read_as_address() with a call to - regcache_cooked_read_unsigned(). The old, ...as_address - function was eventually calling extract_unsigned_integer (via - extract_address) to unpack the registers value. The below is - doing an unsigned extract so that it is functionally - equivalent. The read needs to be cooked as, otherwise, it - will never correctly return the value of a register in the - [NUM_REGS .. NUM_REGS+NUM_PSEUDO_REGS) range. */ - ULONGEST val; - regcache_cooked_read_unsigned (dummy_regs, regno, &val); - return val; + if (dummy_frame_id_eq (&(*dp)->id, dummy_id)) + return dp; } - else - return 0; + + return NULL; } -/* Save all the registers on the dummy frame stack. Most ports save the - registers on the target stack. This results in lots of unnecessary memory - references, which are slow when debugging via a serial line. Instead, we - save all the registers internally, and never write them to the stack. The - registers get restored when the called function returns to the entry point, - where a breakpoint is laying in wait. */ +/* Find the dummy frame by DUMMY_ID and THREAD, and pop it, restoring + program state to that before the frame was created. + On return reinit_frame_cache has been called. + If the frame isn't found, flag an internal error. */ void -generic_push_dummy_frame (void) +dummy_frame_pop (frame_id dummy_id, thread_info *thread) { - struct dummy_frame *dummy_frame; - CORE_ADDR fp = get_frame_base (get_current_frame ()); - - /* check to see if there are stale dummy frames, - perhaps left over from when a longjump took us out of a - function that was called by the debugger */ - - dummy_frame = dummy_frame_stack; - while (dummy_frame) - if (INNER_THAN (dummy_frame->fp, fp)) /* stale -- destroy! */ - { - dummy_frame_stack = dummy_frame->next; - regcache_xfree (dummy_frame->regcache); - xfree (dummy_frame); - dummy_frame = dummy_frame_stack; - } - else - dummy_frame = dummy_frame->next; - - dummy_frame = xmalloc (sizeof (struct dummy_frame)); - dummy_frame->regcache = regcache_xmalloc (current_gdbarch); - - dummy_frame->pc = read_pc (); - dummy_frame->sp = read_sp (); - dummy_frame->top = 0; - dummy_frame->fp = fp; - dummy_frame->id = get_frame_id (get_current_frame ()); - regcache_cpy (dummy_frame->regcache, current_regcache); - dummy_frame->next = dummy_frame_stack; - dummy_frame_stack = dummy_frame; + struct dummy_frame **dp; + struct dummy_frame_id id = { dummy_id, thread }; + + dp = lookup_dummy_frame (&id); + gdb_assert (dp != NULL); + + pop_dummy_frame (dp); } +/* Find the dummy frame by DUMMY_ID and PTID and drop it. Do nothing + if it is not found. Do not restore its state into inferior, just + free its memory. */ + void -generic_save_dummy_frame_tos (CORE_ADDR sp) +dummy_frame_discard (struct frame_id dummy_id, thread_info *thread) { - dummy_frame_stack->top = sp; + struct dummy_frame **dp; + struct dummy_frame_id id = { dummy_id, thread }; + + dp = lookup_dummy_frame (&id); + if (dp) + remove_dummy_frame (dp); } -/* Record the upper/lower bounds on the address of the call dummy. */ +/* See dummy-frame.h. */ void -generic_save_call_dummy_addr (CORE_ADDR lo, CORE_ADDR hi) +register_dummy_frame_dtor (frame_id dummy_id, thread_info *thread, + dummy_frame_dtor_ftype *dtor, void *dtor_data) { - dummy_frame_stack->call_lo = lo; - dummy_frame_stack->call_hi = hi; + struct dummy_frame_id id = { dummy_id, thread }; + struct dummy_frame **dp, *d; + struct dummy_frame_dtor_list *list; + + dp = lookup_dummy_frame (&id); + gdb_assert (dp != NULL); + d = *dp; + list = XNEW (struct dummy_frame_dtor_list); + list->next = d->dtor_list; + d->dtor_list = list; + list->dtor = dtor; + list->dtor_data = dtor_data; } -/* Restore the machine state from either the saved dummy stack or a - real stack frame. */ +/* See dummy-frame.h. */ -void -generic_pop_current_frame (void (*popper) (struct frame_info * frame)) +int +find_dummy_frame_dtor (dummy_frame_dtor_ftype *dtor, void *dtor_data) { - struct frame_info *frame = get_current_frame (); - if (get_frame_type (frame) == DUMMY_FRAME) - /* NOTE: cagney/2002-22-23: Does this ever occure? Surely a dummy - frame will have already been poped by the "infrun.c" code. */ - generic_pop_dummy_frame (); - else - (*popper) (frame); + struct dummy_frame *d; + + for (d = dummy_frame_stack; d != NULL; d = d->next) + { + struct dummy_frame_dtor_list *list; + + for (list = d->dtor_list; list != NULL; list = list->next) + if (list->dtor == dtor && list->dtor_data == dtor_data) + return 1; + } + return 0; } -/* Discard the innermost dummy frame from the dummy frame stack - (passed in as a parameter). */ +/* There may be stale dummy frames, perhaps left over from when an uncaught + longjmp took us out of a function that was called by the debugger. Clean + them up at least once whenever we start a new inferior. */ static void -discard_innermost_dummy (struct dummy_frame **stack) +cleanup_dummy_frames (struct target_ops *target, int from_tty) { - struct dummy_frame *tbd = (*stack); - (*stack) = (*stack)->next; - regcache_xfree (tbd->regcache); - xfree (tbd); + while (dummy_frame_stack != NULL) + remove_dummy_frame (&dummy_frame_stack); } -void -generic_pop_dummy_frame (void) +/* Return the dummy frame cache, it contains both the ID, and a + pointer to the regcache. */ +struct dummy_frame_cache { - struct dummy_frame *dummy_frame = dummy_frame_stack; + struct frame_id this_id; + readonly_detached_regcache *prev_regcache; +}; - /* FIXME: what if the first frame isn't the right one, eg.. - because one call-by-hand function has done a longjmp into another one? */ +static int +dummy_frame_sniffer (const struct frame_unwind *self, + struct frame_info *this_frame, + void **this_prologue_cache) +{ + /* When unwinding a normal frame, the stack structure is determined + by analyzing the frame's function's code (be it using brute force + prologue analysis, or the dwarf2 CFI). In the case of a dummy + frame, that simply isn't possible. The PC is either the program + entry point, or some random address on the stack. Trying to use + that PC to apply standard frame ID unwind techniques is just + asking for trouble. */ + + /* Don't bother unless there is at least one dummy frame. */ + if (dummy_frame_stack != NULL) + { + struct dummy_frame *dummyframe; + /* Use an architecture specific method to extract this frame's + dummy ID, assuming it is a dummy frame. */ + struct frame_id this_id + = gdbarch_dummy_id (get_frame_arch (this_frame), this_frame); + struct dummy_frame_id dummy_id = { this_id, inferior_thread () }; + + /* Use that ID to find the corresponding cache entry. */ + for (dummyframe = dummy_frame_stack; + dummyframe != NULL; + dummyframe = dummyframe->next) + { + if (dummy_frame_id_eq (&dummyframe->id, &dummy_id)) + { + struct dummy_frame_cache *cache; + + cache = FRAME_OBSTACK_ZALLOC (struct dummy_frame_cache); + cache->prev_regcache = get_infcall_suspend_state_regcache + (dummyframe->caller_state); + cache->this_id = this_id; + (*this_prologue_cache) = cache; + return 1; + } + } + } + return 0; +} - if (!dummy_frame) - error ("Can't pop dummy frame!"); - regcache_cpy (current_regcache, dummy_frame->regcache); - flush_cached_frames (); +/* Given a call-dummy dummy-frame, return the registers. Here the + register value is taken from the local copy of the register buffer. */ - discard_innermost_dummy (&dummy_frame_stack); +static struct value * +dummy_frame_prev_register (struct frame_info *this_frame, + void **this_prologue_cache, + int regnum) +{ + struct dummy_frame_cache *cache + = (struct dummy_frame_cache *) *this_prologue_cache; + struct gdbarch *gdbarch = get_frame_arch (this_frame); + struct value *reg_val; + + /* The dummy-frame sniffer always fills in the cache. */ + gdb_assert (cache != NULL); + + /* Describe the register's location. Generic dummy frames always + have the register value in an ``expression''. */ + reg_val = value_zero (register_type (gdbarch, regnum), not_lval); + + /* Use the regcache_cooked_read() method so that it, on the fly, + constructs either a raw or pseudo register from the raw + register cache. */ + cache->prev_regcache->cooked_read (regnum, + value_contents_writeable (reg_val)); + return reg_val; } -/* Function: fix_call_dummy - Stub function. Generic dummy frames typically do not need to fix - the frame being created */ +/* Assuming that THIS_FRAME is a dummy, return its ID. That ID is + determined by examining the NEXT frame's unwound registers using + the method dummy_id(). As a side effect, THIS dummy frame's + dummy cache is located and saved in THIS_PROLOGUE_CACHE. */ -void -generic_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs, - struct value **args, struct type *type, int gcc_p) +static void +dummy_frame_this_id (struct frame_info *this_frame, + void **this_prologue_cache, + struct frame_id *this_id) { - return; + /* The dummy-frame sniffer always fills in the cache. */ + struct dummy_frame_cache *cache + = (struct dummy_frame_cache *) *this_prologue_cache; + + gdb_assert (cache != NULL); + (*this_id) = cache->this_id; } -/* Given a call-dummy dummy-frame, return the registers. Here the - register value is taken from the local copy of the register buffer. */ +const struct frame_unwind dummy_frame_unwind = +{ + DUMMY_FRAME, + default_frame_unwind_stop_reason, + dummy_frame_this_id, + dummy_frame_prev_register, + NULL, + dummy_frame_sniffer, +}; -static void -dummy_frame_register_unwind (struct frame_info *frame, void **cache, - int regnum, int *optimized, - enum lval_type *lvalp, CORE_ADDR *addrp, - int *realnum, void *bufferp) +/* See dummy-frame.h. */ + +struct frame_id +default_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame) { - struct dummy_frame *dummy = cached_find_dummy_frame (frame, cache); - gdb_assert (dummy != NULL); + CORE_ADDR sp, pc; - /* Describe the register's location. Generic dummy frames always - have the register value in an ``expression''. */ - *optimized = 0; - *lvalp = not_lval; - *addrp = 0; - *realnum = -1; + sp = get_frame_sp (this_frame); + pc = get_frame_pc (this_frame); + return frame_id_build (sp, pc); +} - /* If needed, find and return the value of the register. */ - if (bufferp != NULL) +static void +fprint_dummy_frames (struct ui_file *file) +{ + struct dummy_frame *s; + + for (s = dummy_frame_stack; s != NULL; s = s->next) { - /* Return the actual value. */ - /* Use the regcache_cooked_read() method so that it, on the fly, - constructs either a raw or pseudo register from the raw - register cache. */ - regcache_cooked_read (dummy->regcache, regnum, bufferp); + gdb_print_host_address (s, file); + fprintf_unfiltered (file, ":"); + fprintf_unfiltered (file, " id="); + fprint_frame_id (file, s->id.id); + fprintf_unfiltered (file, ", ptid=%s", + target_pid_to_str (s->id.thread->ptid).c_str ()); + fprintf_unfiltered (file, "\n"); } } -/* Assuming that FRAME is a dummy, return the ID of the calling frame - (the frame that the dummy has the saved state of). */ - static void -dummy_frame_id_unwind (struct frame_info *frame, - void **cache, - struct frame_id *id) +maintenance_print_dummy_frames (const char *args, int from_tty) { - struct dummy_frame *dummy = cached_find_dummy_frame (frame, cache); - /* Oops! In a dummy-frame but can't find the stack dummy. Pretend - that the frame doesn't unwind. Should this function instead - return a has-no-caller indication? */ - if (dummy == NULL) - (*id) = null_frame_id; + if (args == NULL) + fprint_dummy_frames (gdb_stdout); else - (*id) = dummy->id; + { + stdio_file file; + + if (!file.open (args, "w")) + perror_with_name (_("maintenance print dummy-frames")); + fprint_dummy_frames (&file); + } } -static struct frame_unwind dummy_frame_unwind = +void +_initialize_dummy_frame (void) { - dummy_frame_id_unwind, - dummy_frame_register_unwind -}; + add_cmd ("dummy-frames", class_maintenance, maintenance_print_dummy_frames, + _("Print the contents of the internal dummy-frame stack."), + &maintenanceprintlist); -const struct frame_unwind * -dummy_frame_p (CORE_ADDR pc) -{ - if (DEPRECATED_PC_IN_CALL_DUMMY_P () - ? DEPRECATED_PC_IN_CALL_DUMMY (pc, 0, 0) - : pc_in_dummy_frame (pc)) - return &dummy_frame_unwind; - else - return NULL; + gdb::observers::inferior_created.attach (cleanup_dummy_frames); }