X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fframe-unwind.c;h=b66febff63966b48a0a00337414a1b2e45366a29;hb=460014f572f44fe3e8deb146cb92fd312c4c3339;hp=ac26a643a840fa791493f48c4d65bc7ca598b119;hpb=4ea2acf05c76ed88f686c27faaf46ab88bfa0f79;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/frame-unwind.c b/gdb/frame-unwind.c index ac26a643a8..b66febff63 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 2003, 2004 Free Software Foundation, Inc. + Copyright (C) 2003-2013 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,30 +15,32 @@ 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" #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" 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; }; struct frame_unwind_table { - struct frame_unwind_table_entry *head; - struct frame_unwind_table_entry **tail; + struct frame_unwind_table_entry *list; + /* The head of the OSABI part of the search list. */ + struct frame_unwind_table_entry **osabi_head; }; static void * @@ -46,60 +48,197 @@ frame_unwind_init (struct obstack *obstack) { struct frame_unwind_table *table = OBSTACK_ZALLOC (obstack, struct frame_unwind_table); - table->head = OBSTACK_ZALLOC (obstack, struct frame_unwind_table_entry); - table->head->sniffer = dummy_frame_sniffer; - table->tail = &table->head->next; + + /* 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->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->next; return table; } void -frame_unwind_append_sniffer (struct gdbarch *gdbarch, - frame_unwind_sniffer_ftype *sniffer) +frame_unwind_prepend_unwinder (struct gdbarch *gdbarch, + const struct frame_unwind *unwinder) { struct frame_unwind_table *table = gdbarch_data (gdbarch, frame_unwind_data); - (*table->tail) = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct frame_unwind_table_entry); - (*table->tail)->sniffer = sniffer; - table->tail = &((*table->tail)->next); + struct frame_unwind_table_entry *entry; + + /* Insert the new entry at the start of the list. */ + entry = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct frame_unwind_table_entry); + entry->unwinder = unwinder; + entry->next = (*table->osabi_head); + (*table->osabi_head) = entry; } void -frame_unwind_register_unwinder (struct gdbarch *gdbarch, - const struct frame_unwind *unwinder) +frame_unwind_append_unwinder (struct gdbarch *gdbarch, + const struct frame_unwind *unwinder) { struct frame_unwind_table *table = gdbarch_data (gdbarch, frame_unwind_data); - (*table->tail) = GDBARCH_OBSTACK_ZALLOC (gdbarch, - struct frame_unwind_table_entry); - (*table->tail)->unwinder = unwinder; - table->tail = &((*table->tail)->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; } -const struct frame_unwind * -frame_unwind_find_by_frame (struct frame_info *next_frame, void **this_cache) +/* 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) { - int i; - struct gdbarch *gdbarch = get_frame_arch (next_frame); + 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; - for (entry = table->head; entry != NULL; entry = entry->next) + + for (entry = table->list; entry != NULL; entry = entry->next) { - if (entry->sniffer != NULL) + struct cleanup *old_cleanup; + volatile struct gdb_exception ex; + int res = 0; + + old_cleanup = frame_prepare_for_sniffer (this_frame, entry->unwinder); + + TRY_CATCH (ex, RETURN_MASK_ERROR) { - const struct frame_unwind *desc = NULL; - desc = entry->sniffer (next_frame); - if (desc != NULL) - return desc; + res = entry->unwinder->sniffer (entry->unwinder, this_frame, + this_cache); } - if (entry->unwinder != NULL) + if (ex.reason < 0 && ex.error == NOT_AVAILABLE_ERROR) { - if (entry->unwinder->sniffer (entry->unwinder, next_frame, - this_cache)) - return entry->unwinder; + /* 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. */ } + else if (ex.reason < 0) + throw_exception (ex); + else if (res) + { + discard_cleanups (old_cleanup); + return; + } + + do_cleanups (old_cleanup); } - return legacy_saved_regs_unwind; + internal_error (__FILE__, __LINE__, _("frame_unwind_find_by_frame failed")); +} + +/* 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; +} + +/* A default frame unwinder stop_reason callback that always claims + the frame is unwindable. */ + +enum unwind_stop_reason +default_frame_unwind_stop_reason (struct frame_info *this_frame, + void **this_cache) +{ + 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 value *reg_val; + + reg_val = value_zero (register_type (gdbarch, regnum), not_lval); + set_value_optimized_out (reg_val, 1); + return reg_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; } -extern initialize_file_ftype _initialize_frame_unwind; /* -Wmissing-prototypes */ +/* -Wmissing-prototypes */ +extern initialize_file_ftype _initialize_frame_unwind; void _initialize_frame_unwind (void)