X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Funwind-dw2-fde-glibc.c;h=b8a7312f50111fa5e67144e6bf2d952f068fe1ba;hb=c88fdff58434a1649af63179686c73ee38b339d3;hp=f6f62c6a19029c02c0f4a2cec6451060a3646a7e;hpb=3e7f6cce419f02371585642d38a34cff8494eaff;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/unwind-dw2-fde-glibc.c b/gcc/unwind-dw2-fde-glibc.c index f6f62c6a190..b8a7312f501 100644 --- a/gcc/unwind-dw2-fde-glibc.c +++ b/gcc/unwind-dw2-fde-glibc.c @@ -1,11 +1,11 @@ -/* Copyright (C) 2001, 2002, 2003 Free Software Foundation, Inc. +/* Copyright (C) 2001, 2002, 2003, 2004, 2005, 2009 Free Software Foundation, Inc. Contributed by Jakub Jelinek . This file is part of GCC. GCC 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, or (at your option) + the Free Software Foundation; either version 3, or (at your option) any later version. GCC is distributed in the hope that it will be useful, @@ -13,17 +13,14 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. - You should have received a copy of the GNU General Public License - along with GCC; see the file COPYING. If not, write to - the Free Software Foundation, 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ + Under Section 7 of GPL version 3, you are granted additional + permissions described in the GCC Runtime Library Exception, version + 3.1, as published by the Free Software Foundation. -/* As a special exception, if you link this library with other files, - some of which are compiled with GCC, to produce an executable, - this library does not by itself cause the resulting executable - to be covered by the GNU General Public License. - This exception does not however invalidate any other reasons why - the executable file might be covered by the GNU General Public License. */ + You should have received a copy of the GNU General Public License and + a copy of the GCC Runtime Library Exception along with this program; + see the files COPYING3 and COPYING.RUNTIME respectively. If not, see + . */ /* Locate the FDE entry for a given address, using PT_GNU_EH_FRAME ELF segment and dl_iterate_phdr to avoid register/deregister calls at @@ -33,7 +30,6 @@ #define _GNU_SOURCE 1 #endif -#include "auto-host.h" /* For HAVE_LD_EH_FRAME_HDR. */ #include "tconfig.h" #include "tsystem.h" #ifndef inhibit_libc @@ -46,11 +42,22 @@ #define NO_BASE_OF_ENCODED_VALUE #include "unwind-pe.h" #include "unwind-dw2-fde.h" +#include "unwind-compat.h" #include "gthr.h" #if !defined(inhibit_libc) && defined(HAVE_LD_EH_FRAME_HDR) \ && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2) \ || (__GLIBC__ == 2 && __GLIBC_MINOR__ == 2 && defined(DT_CONFIG))) +# define USE_PT_GNU_EH_FRAME +#endif + +#if !defined(inhibit_libc) && defined(HAVE_LD_EH_FRAME_HDR) \ + && defined(__FreeBSD__) && __FreeBSD__ >= 7 +# define ElfW __ElfN +# define USE_PT_GNU_EH_FRAME +#endif + +#if defined(USE_PT_GNU_EH_FRAME) #ifndef __RELOC_POINTER # define __RELOC_POINTER(ptr, base) ((ptr) + (base)) @@ -73,6 +80,7 @@ struct unw_eh_callback_data void *dbase; void *func; const fde *ret; + int check_cache; }; struct unw_eh_frame_hdr @@ -83,6 +91,20 @@ struct unw_eh_frame_hdr unsigned char table_enc; }; +#define FRAME_HDR_CACHE_SIZE 8 + +static struct frame_hdr_cache_element +{ + _Unwind_Ptr pc_low; + _Unwind_Ptr pc_high; + _Unwind_Ptr load_base; + const ElfW(Phdr) *p_eh_frame_hdr; + const ElfW(Phdr) *p_dynamic; + struct frame_hdr_cache_element *link; +} frame_hdr_cache[FRAME_HDR_CACHE_SIZE]; + +static struct frame_hdr_cache_element *frame_hdr_cache_head; + /* Like base_of_encoded_value, but take the base from a struct unw_eh_callback_data instead of an _Unwind_Context. */ @@ -103,8 +125,9 @@ base_from_cb_data (unsigned char encoding, struct unw_eh_callback_data *data) return (_Unwind_Ptr) data->tbase; case DW_EH_PE_datarel: return (_Unwind_Ptr) data->dbase; + default: + gcc_unreachable (); } - abort (); } static int @@ -122,11 +145,17 @@ _Unwind_IteratePhdrCallback (struct dl_phdr_info *info, size_t size, void *ptr) const struct unw_eh_frame_hdr *hdr; _Unwind_Ptr eh_frame; struct object ob; + _Unwind_Ptr pc_low = 0, pc_high = 0; - /* Make sure struct dl_phdr_info is at least as big as we need. */ - if (size < offsetof (struct dl_phdr_info, dlpi_phnum) - + sizeof (info->dlpi_phnum)) - return -1; + struct ext_dl_phdr_info + { + ElfW(Addr) dlpi_addr; + const char *dlpi_name; + const ElfW(Phdr) *dlpi_phdr; + ElfW(Half) dlpi_phnum; + unsigned long long int dlpi_adds; + unsigned long long int dlpi_subs; + }; match = 0; phdr = info->dlpi_phdr; @@ -134,6 +163,80 @@ _Unwind_IteratePhdrCallback (struct dl_phdr_info *info, size_t size, void *ptr) p_eh_frame_hdr = NULL; p_dynamic = NULL; + struct frame_hdr_cache_element *prev_cache_entry = NULL, + *last_cache_entry = NULL; + + if (data->check_cache && size >= sizeof (struct ext_dl_phdr_info)) + { + static unsigned long long adds = -1ULL, subs; + struct ext_dl_phdr_info *einfo = (struct ext_dl_phdr_info *) info; + + /* We use a least recently used cache replacement policy. Also, + the most recently used cache entries are placed at the head + of the search chain. */ + + if (einfo->dlpi_adds == adds && einfo->dlpi_subs == subs) + { + /* Find data->pc in shared library cache. + Set load_base, p_eh_frame_hdr and p_dynamic + plus match from the cache and goto + "Read .eh_frame_hdr header." below. */ + + struct frame_hdr_cache_element *cache_entry; + + for (cache_entry = frame_hdr_cache_head; + cache_entry; + cache_entry = cache_entry->link) + { + if (data->pc >= cache_entry->pc_low + && data->pc < cache_entry->pc_high) + { + load_base = cache_entry->load_base; + p_eh_frame_hdr = cache_entry->p_eh_frame_hdr; + p_dynamic = cache_entry->p_dynamic; + + /* And move the entry we're using to the head. */ + if (cache_entry != frame_hdr_cache_head) + { + prev_cache_entry->link = cache_entry->link; + cache_entry->link = frame_hdr_cache_head; + frame_hdr_cache_head = cache_entry; + } + goto found; + } + + last_cache_entry = cache_entry; + /* Exit early if we found an unused entry. */ + if ((cache_entry->pc_low | cache_entry->pc_high) == 0) + break; + if (cache_entry->link != NULL) + prev_cache_entry = cache_entry; + } + } + else + { + adds = einfo->dlpi_adds; + subs = einfo->dlpi_subs; + /* Initialize the cache. Create a chain of cache entries, + with the final one terminated by a NULL link. */ + int i; + for (i = 0; i < FRAME_HDR_CACHE_SIZE; i++) + { + frame_hdr_cache[i].pc_low = 0; + frame_hdr_cache[i].pc_high = 0; + frame_hdr_cache[i].link = &frame_hdr_cache[i+1]; + } + frame_hdr_cache[i-1].link = NULL; + frame_hdr_cache_head = &frame_hdr_cache[0]; + data->check_cache = 0; + } + } + + /* Make sure struct dl_phdr_info is at least as big as we need. */ + if (size < offsetof (struct dl_phdr_info, dlpi_phnum) + + sizeof (info->dlpi_phnum)) + return -1; + /* See if PC falls into one of the loaded segments. Find the eh_frame segment at the same time. */ for (n = info->dlpi_phnum; --n >= 0; phdr++) @@ -143,14 +246,43 @@ _Unwind_IteratePhdrCallback (struct dl_phdr_info *info, size_t size, void *ptr) _Unwind_Ptr vaddr = (_Unwind_Ptr) __RELOC_POINTER (phdr->p_vaddr, load_base); if (data->pc >= vaddr && data->pc < vaddr + phdr->p_memsz) - match = 1; + { + match = 1; + pc_low = vaddr; + pc_high = vaddr + phdr->p_memsz; + } } else if (phdr->p_type == PT_GNU_EH_FRAME) p_eh_frame_hdr = phdr; else if (phdr->p_type == PT_DYNAMIC) p_dynamic = phdr; } - if (!match || !p_eh_frame_hdr) + + if (!match) + return 0; + + if (size >= sizeof (struct ext_dl_phdr_info)) + { + /* Move the cache entry we're about to overwrite to the head of + the list. If either last_cache_entry or prev_cache_entry are + NULL, that cache entry is already at the head. */ + if (last_cache_entry != NULL && prev_cache_entry != NULL) + { + prev_cache_entry->link = last_cache_entry->link; + last_cache_entry->link = frame_hdr_cache_head; + frame_hdr_cache_head = last_cache_entry; + } + + frame_hdr_cache_head->load_base = load_base; + frame_hdr_cache_head->p_eh_frame_hdr = p_eh_frame_hdr; + frame_hdr_cache_head->p_dynamic = p_dynamic; + frame_hdr_cache_head->pc_low = pc_low; + frame_hdr_cache_head->pc_high = pc_high; + } + + found: + + if (!p_eh_frame_hdr) return 0; /* Read .eh_frame_hdr header. */ @@ -236,8 +368,7 @@ _Unwind_IteratePhdrCallback (struct dl_phdr_info *info, size_t size, void *ptr) break; } - if (lo >= hi) - __gxx_abort (); + gcc_assert (lo < hi); } f = (fde *) (table[mid].fde + data_base); @@ -264,11 +395,13 @@ _Unwind_IteratePhdrCallback (struct dl_phdr_info *info, size_t size, void *ptr) data->ret = linear_search_fdes (&ob, (fde *) eh_frame, (void *) data->pc); if (data->ret != NULL) { + _Unwind_Ptr func; unsigned int encoding = get_fde_encoding (data->ret); + read_encoded_value_with_base (encoding, base_from_cb_data (encoding, data), - data->ret->pc_begin, - (_Unwind_Ptr *)&data->func); + data->ret->pc_begin, &func); + data->func = (void *) func; } return 1; } @@ -288,6 +421,7 @@ _Unwind_Find_FDE (void *pc, struct dwarf_eh_bases *bases) data.dbase = NULL; data.func = NULL; data.ret = NULL; + data.check_cache = 1; if (dl_iterate_phdr (_Unwind_IteratePhdrCallback, &data) < 0) return NULL; @@ -306,3 +440,7 @@ _Unwind_Find_FDE (void *pc, struct dwarf_eh_bases *bases) #define _Unwind_Find_FDE _Unwind_Find_FDE #include "unwind-dw2-fde.c" #endif + +#if defined (USE_GAS_SYMVER) && defined (SHARED) && defined (USE_LIBUNWIND_EXCEPTIONS) +alias (_Unwind_Find_FDE); +#endif