X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fframe-unwind.c;h=fdfea6e5e4fdd6d5c579700a428d23996e148578;hb=2117c711ae07700adb57ea5b5ca61e4c32d7e3d2;hp=e835edfab07a5197ecb83f4837572673a275be79;hpb=01f0fe5e0450edf168c1f612feb93cf588e4e7ea;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/frame-unwind.c b/gdb/frame-unwind.c index e835edfab0..fdfea6e5e4 100644 --- a/gdb/frame-unwind.c +++ b/gdb/frame-unwind.c @@ -1,12 +1,12 @@ /* Definitions for frame unwinder, for GDB, the GNU debugger. - Copyright (C) 2003, 2004 Free Software Foundation, Inc. + Copyright (C) 2003-2014 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, @@ -15,22 +15,24 @@ 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., 51 Franklin Street, Fifth Floor, - Boston, MA 02110-1301, USA. */ + along with this program. If not, see . */ #include "defs.h" #include "frame.h" #include "frame-unwind.h" -#include "gdb_assert.h" #include "dummy-frame.h" +#include "inline-frame.h" +#include "value.h" +#include "regcache.h" +#include "exceptions.h" +#include "gdb_assert.h" #include "gdb_obstack.h" +#include "target.h" static struct gdbarch_data *frame_unwind_data; struct frame_unwind_table_entry { - frame_unwind_sniffer_ftype *sniffer; const struct frame_unwind *unwinder; struct frame_unwind_table_entry *next; }; @@ -47,28 +49,19 @@ frame_unwind_init (struct obstack *obstack) { struct frame_unwind_table *table = OBSTACK_ZALLOC (obstack, struct frame_unwind_table); + /* Start the table out with a few default sniffers. OSABI code can't override this. */ table->list = OBSTACK_ZALLOC (obstack, struct frame_unwind_table_entry); - table->list->unwinder = dummy_frame_unwind; + table->list->unwinder = &dummy_frame_unwind; + table->list->next = OBSTACK_ZALLOC (obstack, + struct frame_unwind_table_entry); + table->list->next->unwinder = &inline_frame_unwind; /* The insertion point for OSABI sniffers. */ - table->osabi_head = &table->list->next; + table->osabi_head = &table->list->next->next; return table; } -void -frame_unwind_append_sniffer (struct gdbarch *gdbarch, - frame_unwind_sniffer_ftype *sniffer) -{ - struct frame_unwind_table *table = gdbarch_data (gdbarch, frame_unwind_data); - struct frame_unwind_table_entry **ip; - - /* Find the end of the list and insert the new entry there. */ - for (ip = table->osabi_head; (*ip) != NULL; ip = &(*ip)->next); - (*ip) = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct frame_unwind_table_entry); - (*ip)->sniffer = sniffer; -} - void frame_unwind_prepend_unwinder (struct gdbarch *gdbarch, const struct frame_unwind *unwinder) @@ -83,33 +76,210 @@ frame_unwind_prepend_unwinder (struct gdbarch *gdbarch, (*table->osabi_head) = entry; } -const struct frame_unwind * -frame_unwind_find_by_frame (struct frame_info *next_frame, void **this_cache) +void +frame_unwind_append_unwinder (struct gdbarch *gdbarch, + const struct frame_unwind *unwinder) { - int i; - struct gdbarch *gdbarch = get_frame_arch (next_frame); struct frame_unwind_table *table = gdbarch_data (gdbarch, frame_unwind_data); - struct frame_unwind_table_entry *entry; - for (entry = table->list; entry != NULL; entry = entry->next) + struct frame_unwind_table_entry **ip; + + /* Find the end of the list and insert the new entry there. */ + for (ip = table->osabi_head; (*ip) != NULL; ip = &(*ip)->next); + (*ip) = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct frame_unwind_table_entry); + (*ip)->unwinder = unwinder; +} + +/* Call SNIFFER from UNWINDER. If it succeeded set UNWINDER for + THIS_FRAME and return 1. Otherwise the function keeps THIS_FRAME + unchanged and returns 0. */ + +static int +frame_unwind_try_unwinder (struct frame_info *this_frame, void **this_cache, + const struct frame_unwind *unwinder) +{ + struct cleanup *old_cleanup; + volatile struct gdb_exception ex; + int res = 0; + + old_cleanup = frame_prepare_for_sniffer (this_frame, unwinder); + + TRY_CATCH (ex, RETURN_MASK_ERROR) { - if (entry->sniffer != NULL) - { - const struct frame_unwind *desc = NULL; - desc = entry->sniffer (next_frame); - if (desc != NULL) - return desc; - } - if (entry->unwinder != NULL) - { - if (entry->unwinder->sniffer (entry->unwinder, next_frame, - this_cache)) - return entry->unwinder; - } + res = unwinder->sniffer (unwinder, this_frame, this_cache); } + if (ex.reason < 0 && ex.error == NOT_AVAILABLE_ERROR) + { + /* This usually means that not even the PC is available, + thus most unwinders aren't able to determine if they're + the best fit. Keep trying. Fallback prologue unwinders + should always accept the frame. */ + do_cleanups (old_cleanup); + return 0; + } + else if (ex.reason < 0) + throw_exception (ex); + else if (res) + { + discard_cleanups (old_cleanup); + return 1; + } + else + { + do_cleanups (old_cleanup); + return 0; + } + gdb_assert_not_reached ("frame_unwind_try_unwinder"); +} + +/* Iterate through sniffers for THIS_FRAME frame until one returns with an + unwinder implementation. THIS_FRAME->UNWIND must be NULL, it will get set + by this function. Possibly initialize THIS_CACHE. */ + +void +frame_unwind_find_by_frame (struct frame_info *this_frame, void **this_cache) +{ + struct gdbarch *gdbarch = get_frame_arch (this_frame); + struct frame_unwind_table *table = gdbarch_data (gdbarch, frame_unwind_data); + struct frame_unwind_table_entry *entry; + const struct frame_unwind *unwinder_from_target; + + unwinder_from_target = target_get_unwinder (); + if (unwinder_from_target != NULL + && frame_unwind_try_unwinder (this_frame, this_cache, + unwinder_from_target)) + return; + + unwinder_from_target = target_get_tailcall_unwinder (); + if (unwinder_from_target != NULL + && frame_unwind_try_unwinder (this_frame, this_cache, + unwinder_from_target)) + return; + + for (entry = table->list; entry != NULL; entry = entry->next) + if (frame_unwind_try_unwinder (this_frame, this_cache, entry->unwinder)) + return; + internal_error (__FILE__, __LINE__, _("frame_unwind_find_by_frame failed")); } -extern initialize_file_ftype _initialize_frame_unwind; /* -Wmissing-prototypes */ +/* A default frame sniffer which always accepts the frame. Used by + fallback prologue unwinders. */ + +int +default_frame_sniffer (const struct frame_unwind *self, + struct frame_info *this_frame, + void **this_prologue_cache) +{ + return 1; +} + +/* The default frame unwinder stop_reason callback. */ + +enum unwind_stop_reason +default_frame_unwind_stop_reason (struct frame_info *this_frame, + void **this_cache) +{ + struct frame_id this_id = get_frame_id (this_frame); + + if (frame_id_eq (this_id, outer_frame_id)) + return UNWIND_OUTERMOST; + else + return UNWIND_NO_REASON; +} + +/* Helper functions for value-based register unwinding. These return + a (possibly lazy) value of the appropriate type. */ + +/* Return a value which indicates that FRAME did not save REGNUM. */ + +struct value * +frame_unwind_got_optimized (struct frame_info *frame, int regnum) +{ + struct gdbarch *gdbarch = frame_unwind_arch (frame); + struct type *type = register_type (gdbarch, regnum); + struct value *val; + + /* Return an lval_register value, so that we print it as + "". */ + val = allocate_value_lazy (type); + set_value_lazy (val, 0); + set_value_optimized_out (val, 1); + VALUE_LVAL (val) = lval_register; + VALUE_REGNUM (val) = regnum; + VALUE_FRAME_ID (val) = get_frame_id (frame); + return val; +} + +/* Return a value which indicates that FRAME copied REGNUM into + register NEW_REGNUM. */ + +struct value * +frame_unwind_got_register (struct frame_info *frame, + int regnum, int new_regnum) +{ + return value_of_register_lazy (frame, new_regnum); +} + +/* Return a value which indicates that FRAME saved REGNUM in memory at + ADDR. */ + +struct value * +frame_unwind_got_memory (struct frame_info *frame, int regnum, CORE_ADDR addr) +{ + struct gdbarch *gdbarch = frame_unwind_arch (frame); + struct value *v = value_at_lazy (register_type (gdbarch, regnum), addr); + + set_value_stack (v, 1); + return v; +} + +/* Return a value which indicates that FRAME's saved version of + REGNUM has a known constant (computed) value of VAL. */ + +struct value * +frame_unwind_got_constant (struct frame_info *frame, int regnum, + ULONGEST val) +{ + struct gdbarch *gdbarch = frame_unwind_arch (frame); + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + struct value *reg_val; + + reg_val = value_zero (register_type (gdbarch, regnum), not_lval); + store_unsigned_integer (value_contents_writeable (reg_val), + register_size (gdbarch, regnum), byte_order, val); + return reg_val; +} + +struct value * +frame_unwind_got_bytes (struct frame_info *frame, int regnum, gdb_byte *buf) +{ + struct gdbarch *gdbarch = frame_unwind_arch (frame); + struct value *reg_val; + + reg_val = value_zero (register_type (gdbarch, regnum), not_lval); + memcpy (value_contents_raw (reg_val), buf, register_size (gdbarch, regnum)); + return reg_val; +} + +/* Return a value which indicates that FRAME's saved version of REGNUM + has a known constant (computed) value of ADDR. Convert the + CORE_ADDR to a target address if necessary. */ + +struct value * +frame_unwind_got_address (struct frame_info *frame, int regnum, + CORE_ADDR addr) +{ + struct gdbarch *gdbarch = frame_unwind_arch (frame); + struct value *reg_val; + + reg_val = value_zero (register_type (gdbarch, regnum), not_lval); + pack_long (value_contents_writeable (reg_val), + register_type (gdbarch, regnum), addr); + return reg_val; +} + +/* -Wmissing-prototypes */ +extern initialize_file_ftype _initialize_frame_unwind; void _initialize_frame_unwind (void)