X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fdummy-frame.c;h=2fe578ee6bfdb18f9f7b61e6146890a31731ac8c;hb=63ffd7c9131c0e9723016d33cf8d435cc508d02b;hp=36c7dbb690aa7e1e7bd32b3ec7e3a4ec36cd847b;hpb=336d1bba0aa5fa96bab6d7fb23317be1374ad151;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/dummy-frame.c b/gdb/dummy-frame.c index 36c7dbb690..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,14 +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; +} + +/* 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 @@ -44,423 +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. */ - 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. */ +void +dummy_frame_push (struct infcall_suspend_state *caller_state, + const frame_id *dummy_id, thread_info *thread) +{ + struct dummy_frame *dummy_frame; -static struct dummy_frame * -find_dummy_frame (CORE_ADDR pc, CORE_ADDR fp) + 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; +} + +/* Remove *DUMMY_PTR from the dummy frame stack. */ + +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 - UNWIND_DUMMY_ID(). */ - 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; + + 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); } -struct regcache * -deprecated_find_dummy_frame_regcache (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 = deprecated_find_dummy_frame_regcache (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 - !DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET_P yet generic dummy - targets set DEPRECATED_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 = deprecated_find_dummy_frame_regcache (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 (nee - 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; - - /* 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? */ - - if (!dummy_frame) - error ("Can't pop dummy frame!"); - regcache_cpy (current_regcache, dummy_frame->regcache); - flush_cached_frames (); + struct frame_id this_id; + readonly_detached_regcache *prev_regcache; +}; - discard_innermost_dummy (&dummy_frame_stack); +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; } /* Given a call-dummy dummy-frame, return the registers. Here the register value is taken from the local copy of the register buffer. */ -static void -dummy_frame_prev_register (struct frame_info *next_frame, +static struct value * +dummy_frame_prev_register (struct frame_info *this_frame, void **this_prologue_cache, - int regnum, int *optimized, - enum lval_type *lvalp, CORE_ADDR *addrp, - int *realnum, void *bufferp) + int regnum) { - struct dummy_frame *dummy; - struct frame_id id; + struct dummy_frame_cache *cache + = (struct dummy_frame_cache *) *this_prologue_cache; + struct gdbarch *gdbarch = get_frame_arch (this_frame); + struct value *reg_val; - /* 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); + /* 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''. */ - *optimized = 0; - *lvalp = not_lval; - *addrp = 0; - *realnum = -1; - - /* If needed, find and return the value of the register. */ - if (bufferp != NULL) - { - /* 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); - } + 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 (remember, the NEXT and not - THIS frame is passed in), return the ID of THIS frame. That ID is +/* 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 unwind_dummy_id(). As a side effect, THIS dummy frame's - dummy cache is located and and saved in THIS_PROLOGUE_CACHE. */ + 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 *next_frame, +dummy_frame_this_id (struct frame_info *this_frame, void **this_prologue_cache, struct frame_id *this_id) { - 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 - frame, that simply isn't possible. The 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. */ - if (gdbarch_unwind_dummy_id_p (current_gdbarch)) - { - /* 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. */ - (*this_id) = gdbarch_unwind_dummy_id (current_gdbarch, next_frame); - } - else if (frame_relative_level (next_frame) < 0) - { - /* We're unwinding a sentinel frame, the PC of which is pointing - at a stack dummy. Fake up the dummy frame's ID using the - same sequence as is found a traditional unwinder. Once all - architectures supply the unwind_dummy_id method, this code - can go away. */ - (*this_id) = frame_id_build (deprecated_read_fp (), read_pc ()); - } - else if (legacy_frame_p (current_gdbarch) - && get_prev_frame (next_frame)) - { - /* Things are looking seriously grim! Assume that the legacy - get_prev_frame code has already created THIS frame and linked - it in to the frame chain (a pretty bold assumption), extract - the ID from THIS base / pc. */ - (*this_id) = frame_id_build (get_frame_base (get_prev_frame (next_frame)), - get_frame_pc (get_prev_frame (next_frame))); - } - else - { - /* Outch! We're not trying to find the innermost frame's ID yet - we're trying to unwind to a dummy. The architecture must - provide the unwind_dummy_id() method. Abandon the unwind - process but only after first warning the user. */ - internal_warning (__FILE__, __LINE__, - "Missing unwind_dummy_id architecture method"); - (*this_id) = null_frame_id; - return; - } - (*this_prologue_cache) = find_dummy_frame ((*this_id).code_addr, - (*this_id).stack_addr); + /* 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 (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; + 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, " fp=0x%s", paddr (s->fp)); - fprintf_unfiltered (file, " sp=0x%s", paddr (s->sp)); - 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); }