X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fdummy-frame.c;h=3b76d456b7b134b5d524263898278ca98ff0b380;hb=086baaf1346f07acfb6708e8c6cb79274241488b;hp=d901214c37c22d3ec1fd78fdb8adf49542a27cf2;hpb=a81dcb0537c784568efe7448b9d04b1d6b2673dd;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/dummy-frame.c b/gdb/dummy-frame.c index d901214c37..3b76d456b7 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, 2003, 2004 Free - Software Foundation, Inc. + Copyright (C) 1986-2019 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,16 +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" -static void dummy_frame_this_id (struct frame_info *next_frame, - void **this_prologue_cache, - struct frame_id *this_id); +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; +} -static int pc_in_dummy_frame (CORE_ADDR pc); +/* 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 @@ -46,199 +72,226 @@ 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 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? */ - /* "infcall.c" explicitly saved the top-of-stack before the - inferior function call, assume unwind_dummy_id() returns that - same stack value. */ - if (fp != dummyframe->top) - continue; - /* The FP matches this dummy frame. */ - return dummyframe; + struct dummy_frame_dtor_list *list = dummy->dtor_list; + + dummy->dtor_list = list->next; + list->dtor (list->dtor_data, 0); + xfree (list); } - return NULL; + *dummy_ptr = dummy->next; + discard_infcall_suspend_state (dummy->caller_state); + xfree (dummy); } -/* Function: pc_in_call_dummy (pc) - - 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. */ +/* Delete any breakpoint B which is a momentary breakpoint for return from + inferior call matching DUMMY_VOIDP. */ -int -deprecated_pc_in_call_dummy (CORE_ADDR pc) +static bool +pop_dummy_frame_bpt (struct breakpoint *b, struct dummy_frame *dummy) { - return pc_in_dummy_frame (pc); -} + 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); -/* Return non-zero if the PC falls in a dummy frame. + delete_breakpoint (b); - 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; + } - 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. */ + /* Continue the traversal. */ + return false; +} -static int -pc_in_dummy_frame (CORE_ADDR pc) +/* Pop *DUMMY_PTR, restoring program state to that before the + frame was created. */ + +static void +pop_dummy_frame (struct dummy_frame **dummy_ptr) { - struct dummy_frame *dummyframe; - for (dummyframe = dummy_frame_stack; - dummyframe != NULL; - dummyframe = dummyframe->next) + struct dummy_frame *dummy = *dummy_ptr; + + gdb_assert (dummy->id.thread == inferior_thread ()); + + 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 (); } -/* 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. */ +/* Look up DUMMY_ID. + Return NULL if not found. */ -void -generic_push_dummy_frame (void) +static struct dummy_frame ** +lookup_dummy_frame (struct dummy_frame_id *dummy_id) { - 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 (gdbarch_inner_than (current_gdbarch, dummy_frame->top, 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 = frame_save_as_regcache (get_current_frame ()); - - dummy_frame->pc = read_pc (); - dummy_frame->top = 0; - dummy_frame->id = get_frame_id (get_current_frame ()); - dummy_frame->next = dummy_frame_stack; - dummy_frame_stack = dummy_frame; + struct dummy_frame **dp; + + for (dp = &dummy_frame_stack; *dp != NULL; dp = &(*dp)->next) + { + if (dummy_frame_id_eq (&(*dp)->id, dummy_id)) + return dp; + } + + return NULL; } +/* 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_save_dummy_frame_tos (CORE_ADDR sp) +dummy_frame_pop (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); + gdb_assert (dp != NULL); + + pop_dummy_frame (dp); } -/* Record the upper/lower bounds on the address of the call dummy. */ +/* 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_call_dummy_addr (CORE_ADDR lo, CORE_ADDR hi) +dummy_frame_discard (struct frame_id dummy_id, thread_info *thread) { - dummy_frame_stack->call_lo = lo; - dummy_frame_stack->call_hi = hi; + struct dummy_frame **dp; + struct dummy_frame_id id = { dummy_id, thread }; + + dp = lookup_dummy_frame (&id); + if (dp) + remove_dummy_frame (dp); } -/* Given a call-dummy dummy-frame, return the registers. Here the - register value is taken from the local copy of the register buffer. */ +/* See dummy-frame.h. */ -static void -dummy_frame_prev_register (struct frame_info *next_frame, - void **this_prologue_cache, - int regnum, int *optimized, - enum lval_type *lvalp, CORE_ADDR *addrp, - int *realnum, void *bufferp) +void +register_dummy_frame_dtor (frame_id dummy_id, thread_info *thread, + dummy_frame_dtor_ftype *dtor, void *dtor_data) { - struct dummy_frame *dummy; - struct frame_id id; + 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; +} - /* Call the ID method which, if at all possible, will set the - prologue cache. */ - dummy_frame_this_id (next_frame, this_prologue_cache, &id); - dummy = (*this_prologue_cache); - gdb_assert (dummy != NULL); +/* See dummy-frame.h. */ - /* 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; +int +find_dummy_frame_dtor (dummy_frame_dtor_ftype *dtor, void *dtor_data) +{ + struct dummy_frame *d; - /* If needed, find and return the value of the register. */ - if (bufferp != NULL) + for (d = dummy_frame_stack; d != NULL; d = d->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); + 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; } -/* Assuming that THIS frame is a dummy (remember, the NEXT and not - THIS frame is passed in), return the ID of THIS frame. That ID is - determined by examining the NEXT frame's unwound registers using - the method unwind_dummy_id(). As a side effect, THIS dummy frame's - dummy cache is located and and saved in THIS_PROLOGUE_CACHE. */ +/* 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 -dummy_frame_this_id (struct frame_info *next_frame, - void **this_prologue_cache, - struct frame_id *this_id) +cleanup_dummy_frames (struct target_ops *target, int from_tty) +{ + while (dummy_frame_stack != NULL) + remove_dummy_frame (&dummy_frame_stack); +} + +/* Return the dummy frame cache, it contains both the ID, and a + pointer to the regcache. */ +struct dummy_frame_cache +{ + struct frame_id this_id; + readonly_detached_regcache *prev_regcache; +}; + +static int +dummy_frame_sniffer (const struct frame_unwind *self, + struct frame_info *this_frame, + void **this_prologue_cache) { - struct dummy_frame *dummy = (*this_prologue_cache); - if (dummy != NULL) - { - (*this_id) = dummy->id; - return; - } /* 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 @@ -246,73 +299,144 @@ dummy_frame_this_id (struct frame_info *next_frame, 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. */ - /* Use an architecture specific method to extract the prev's dummy - ID from the next frame. Note that this method uses - frame_register_unwind to obtain the register values needed to - determine the dummy frame's ID. */ - gdb_assert (gdbarch_unwind_dummy_id_p (current_gdbarch)); - (*this_id) = gdbarch_unwind_dummy_id (current_gdbarch, next_frame); - (*this_prologue_cache) = find_dummy_frame ((*this_id).code_addr, - (*this_id).stack_addr); + + /* 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; +} + +/* Given a call-dummy dummy-frame, return the registers. Here the + register value is taken from the local copy of the register buffer. */ + +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; +} + +/* 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. */ + +static void +dummy_frame_this_id (struct frame_info *this_frame, + void **this_prologue_cache, + struct frame_id *this_id) +{ + /* 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; } -static struct frame_unwind dummy_frame_unwind = +const struct frame_unwind dummy_frame_unwind = { DUMMY_FRAME, + default_frame_unwind_stop_reason, dummy_frame_this_id, - dummy_frame_prev_register + dummy_frame_prev_register, + NULL, + dummy_frame_sniffer, }; -const struct frame_unwind * -dummy_frame_sniffer (struct frame_info *next_frame) +/* See dummy-frame.h. */ + +struct frame_id +default_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame) { - CORE_ADDR pc = frame_pc_unwind (next_frame); - if (pc_in_dummy_frame (pc)) - return &dummy_frame_unwind; - else - return NULL; + CORE_ADDR sp, pc; + + sp = get_frame_sp (this_frame); + pc = get_frame_pc (this_frame); + return frame_id_build (sp, pc); } static void fprint_dummy_frames (struct ui_file *file) { struct dummy_frame *s; + for (s = dummy_frame_stack; s != NULL; s = s->next) { gdb_print_host_address (s, file); fprintf_unfiltered (file, ":"); - fprintf_unfiltered (file, " pc=0x%s", paddr (s->pc)); - fprintf_unfiltered (file, " top=0x%s", paddr (s->top)); fprintf_unfiltered (file, " id="); - fprint_frame_id (file, s->id); - fprintf_unfiltered (file, " call_lo=0x%s", paddr (s->call_lo)); - fprintf_unfiltered (file, " call_hi=0x%s", paddr (s->call_hi)); + 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"); } } static void -maintenance_print_dummy_frames (char *args, int from_tty) +maintenance_print_dummy_frames (const char *args, int from_tty) { if (args == NULL) fprint_dummy_frames (gdb_stdout); else { - struct ui_file *file = gdb_fopen (args, "w"); - if (file == NULL) - perror_with_name ("maintenance print dummy-frames"); - fprint_dummy_frames (file); - ui_file_delete (file); + stdio_file file; + + if (!file.open (args, "w")) + perror_with_name (_("maintenance print dummy-frames")); + fprint_dummy_frames (&file); } } -extern void _initialize_dummy_frame (void); - void _initialize_dummy_frame (void) { add_cmd ("dummy-frames", class_maintenance, maintenance_print_dummy_frames, - "Print the contents of the internal dummy-frame stack.", + _("Print the contents of the internal dummy-frame stack."), &maintenanceprintlist); + gdb::observers::inferior_created.attach (cleanup_dummy_frames); }