1/* Copyright (C) 2001-2015 Free Software Foundation, Inc.
2   Contributed by Jakub Jelinek <jakub@redhat.com>.
3
4   This file is part of GCC.
5
6   GCC is free software; you can redistribute it and/or modify
7   it under the terms of the GNU General Public License as published by
8   the Free Software Foundation; either version 3, or (at your option)
9   any later version.
10
11   GCC is distributed in the hope that it will be useful,
12   but WITHOUT ANY WARRANTY; without even the implied warranty of
13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14   GNU General Public License for more details.
15
16   Under Section 7 of GPL version 3, you are granted additional
17   permissions described in the GCC Runtime Library Exception, version
18   3.1, as published by the Free Software Foundation.
19
20   You should have received a copy of the GNU General Public License and
21   a copy of the GCC Runtime Library Exception along with this program;
22   see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23   <http://www.gnu.org/licenses/>.  */
24
25/* Locate the FDE entry for a given address, using PT_GNU_EH_FRAME ELF
26   segment and dl_iterate_phdr to avoid register/deregister calls at
27   DSO load/unload.  */
28
29#ifndef _GNU_SOURCE
30#define _GNU_SOURCE 1
31#endif
32
33#include "tconfig.h"
34#include "tsystem.h"
35#if !defined(inhibit_libc) && !defined(__OpenBSD__)
36#include <elf.h>		/* Get DT_CONFIG.  */
37#endif
38#include "coretypes.h"
39#include "tm.h"
40#include "libgcc_tm.h"
41#include "dwarf2.h"
42#include "unwind.h"
43#define NO_BASE_OF_ENCODED_VALUE
44#include "unwind-pe.h"
45#include "unwind-dw2-fde.h"
46#include "unwind-compat.h"
47#include "gthr.h"
48
49#if !defined(inhibit_libc) && defined(HAVE_LD_EH_FRAME_HDR) \
50    && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2) \
51	|| (__GLIBC__ == 2 && __GLIBC_MINOR__ == 2 && defined(DT_CONFIG)))
52# define USE_PT_GNU_EH_FRAME
53#endif
54
55#if !defined(inhibit_libc) && defined(HAVE_LD_EH_FRAME_HDR) \
56    && defined(__BIONIC__)
57# define USE_PT_GNU_EH_FRAME
58#endif
59
60#if !defined(inhibit_libc) && defined(HAVE_LD_EH_FRAME_HDR) \
61    && defined(TARGET_DL_ITERATE_PHDR) \
62    && (defined(__DragonFly__) || defined(__FreeBSD__))
63# define ElfW __ElfN
64# define USE_PT_GNU_EH_FRAME
65#endif
66
67#if !defined(inhibit_libc) && defined(HAVE_LD_EH_FRAME_HDR) \
68    && defined(__OpenBSD__)
69# define ElfW(type) Elf_##type
70# define USE_PT_GNU_EH_FRAME
71#endif
72
73#if !defined(inhibit_libc) && defined(HAVE_LD_EH_FRAME_HDR) \
74    && defined(TARGET_DL_ITERATE_PHDR) \
75    && defined(__sun__) && defined(__svr4__)
76# define USE_PT_GNU_EH_FRAME
77#endif
78
79#if defined(USE_PT_GNU_EH_FRAME)
80
81#include <link.h>
82
83#ifndef __RELOC_POINTER
84# define __RELOC_POINTER(ptr, base) ((ptr) + (base))
85#endif
86
87static const fde * _Unwind_Find_registered_FDE (void *pc, struct dwarf_eh_bases *bases);
88
89#define _Unwind_Find_FDE _Unwind_Find_registered_FDE
90#include "unwind-dw2-fde.c"
91#undef _Unwind_Find_FDE
92
93#ifndef PT_GNU_EH_FRAME
94#define PT_GNU_EH_FRAME (PT_LOOS + 0x474e550)
95#endif
96
97struct unw_eh_callback_data
98{
99  _Unwind_Ptr pc;
100  void *tbase;
101  void *dbase;
102  void *func;
103  const fde *ret;
104  int check_cache;
105};
106
107struct unw_eh_frame_hdr
108{
109  unsigned char version;
110  unsigned char eh_frame_ptr_enc;
111  unsigned char fde_count_enc;
112  unsigned char table_enc;
113};
114
115#define FRAME_HDR_CACHE_SIZE 8
116
117static struct frame_hdr_cache_element
118{
119  _Unwind_Ptr pc_low;
120  _Unwind_Ptr pc_high;
121  _Unwind_Ptr load_base;
122  const ElfW(Phdr) *p_eh_frame_hdr;
123  const ElfW(Phdr) *p_dynamic;
124  struct frame_hdr_cache_element *link;
125} frame_hdr_cache[FRAME_HDR_CACHE_SIZE];
126
127static struct frame_hdr_cache_element *frame_hdr_cache_head;
128
129/* Like base_of_encoded_value, but take the base from a struct
130   unw_eh_callback_data instead of an _Unwind_Context.  */
131
132static _Unwind_Ptr
133base_from_cb_data (unsigned char encoding, struct unw_eh_callback_data *data)
134{
135  if (encoding == DW_EH_PE_omit)
136    return 0;
137
138  switch (encoding & 0x70)
139    {
140    case DW_EH_PE_absptr:
141    case DW_EH_PE_pcrel:
142    case DW_EH_PE_aligned:
143      return 0;
144
145    case DW_EH_PE_textrel:
146      return (_Unwind_Ptr) data->tbase;
147    case DW_EH_PE_datarel:
148      return (_Unwind_Ptr) data->dbase;
149    default:
150      gcc_unreachable ();
151    }
152}
153
154static int
155_Unwind_IteratePhdrCallback (struct dl_phdr_info *info, size_t size, void *ptr)
156{
157  struct unw_eh_callback_data *data = (struct unw_eh_callback_data *) ptr;
158  const ElfW(Phdr) *phdr, *p_eh_frame_hdr, *p_dynamic;
159  long n, match;
160#ifdef __FRV_FDPIC__
161  struct elf32_fdpic_loadaddr load_base;
162#else
163  _Unwind_Ptr load_base;
164#endif
165  const unsigned char *p;
166  const struct unw_eh_frame_hdr *hdr;
167  _Unwind_Ptr eh_frame;
168  struct object ob;
169  _Unwind_Ptr pc_low = 0, pc_high = 0;
170
171  struct ext_dl_phdr_info
172    {
173      ElfW(Addr) dlpi_addr;
174      const char *dlpi_name;
175      const ElfW(Phdr) *dlpi_phdr;
176      ElfW(Half) dlpi_phnum;
177      unsigned long long int dlpi_adds;
178      unsigned long long int dlpi_subs;
179    };
180
181  match = 0;
182  phdr = info->dlpi_phdr;
183  load_base = info->dlpi_addr;
184  p_eh_frame_hdr = NULL;
185  p_dynamic = NULL;
186
187  struct frame_hdr_cache_element *prev_cache_entry = NULL,
188    *last_cache_entry = NULL;
189
190  if (data->check_cache && size >= sizeof (struct ext_dl_phdr_info))
191    {
192      static unsigned long long adds = -1ULL, subs;
193      struct ext_dl_phdr_info *einfo = (struct ext_dl_phdr_info *) info;
194
195      /* We use a least recently used cache replacement policy.  Also,
196	 the most recently used cache entries are placed at the head
197	 of the search chain.  */
198
199      if (einfo->dlpi_adds == adds && einfo->dlpi_subs == subs)
200	{
201	  /* Find data->pc in shared library cache.
202	     Set load_base, p_eh_frame_hdr and p_dynamic
203	     plus match from the cache and goto
204	     "Read .eh_frame_hdr header." below.  */
205
206	  struct frame_hdr_cache_element *cache_entry;
207
208	  for (cache_entry = frame_hdr_cache_head;
209	       cache_entry;
210	       cache_entry = cache_entry->link)
211	    {
212	      if (data->pc >= cache_entry->pc_low
213		  && data->pc < cache_entry->pc_high)
214		{
215		  load_base = cache_entry->load_base;
216		  p_eh_frame_hdr = cache_entry->p_eh_frame_hdr;
217		  p_dynamic = cache_entry->p_dynamic;
218
219		  /* And move the entry we're using to the head.  */
220		  if (cache_entry != frame_hdr_cache_head)
221		    {
222		      prev_cache_entry->link = cache_entry->link;
223		      cache_entry->link = frame_hdr_cache_head;
224		      frame_hdr_cache_head = cache_entry;
225		    }
226		  goto found;
227		}
228
229	      last_cache_entry = cache_entry;
230	      /* Exit early if we found an unused entry.  */
231	      if ((cache_entry->pc_low | cache_entry->pc_high) == 0)
232		break;
233	      if (cache_entry->link != NULL)
234		prev_cache_entry = cache_entry;
235	    }
236	}
237      else
238	{
239	  adds = einfo->dlpi_adds;
240	  subs = einfo->dlpi_subs;
241	  /* Initialize the cache.  Create a chain of cache entries,
242	     with the final one terminated by a NULL link.  */
243	  int i;
244	  for (i = 0; i < FRAME_HDR_CACHE_SIZE; i++)
245	    {
246	      frame_hdr_cache[i].pc_low = 0;
247	      frame_hdr_cache[i].pc_high = 0;
248	      frame_hdr_cache[i].link = &frame_hdr_cache[i+1];
249	    }
250	  frame_hdr_cache[i-1].link = NULL;
251	  frame_hdr_cache_head = &frame_hdr_cache[0];
252	  data->check_cache = 0;
253	}
254    }
255
256  /* Make sure struct dl_phdr_info is at least as big as we need.  */
257  if (size < offsetof (struct dl_phdr_info, dlpi_phnum)
258	     + sizeof (info->dlpi_phnum))
259    return -1;
260
261  /* See if PC falls into one of the loaded segments.  Find the eh_frame
262     segment at the same time.  */
263  for (n = info->dlpi_phnum; --n >= 0; phdr++)
264    {
265      if (phdr->p_type == PT_LOAD)
266	{
267	  _Unwind_Ptr vaddr = (_Unwind_Ptr)
268	    __RELOC_POINTER (phdr->p_vaddr, load_base);
269	  if (data->pc >= vaddr && data->pc < vaddr + phdr->p_memsz)
270	    {
271	      match = 1;
272	      pc_low = vaddr;
273	      pc_high =  vaddr + phdr->p_memsz;
274	    }
275	}
276      else if (phdr->p_type == PT_GNU_EH_FRAME)
277	p_eh_frame_hdr = phdr;
278#ifdef PT_SUNW_UNWIND
279      /* Sun ld emits PT_SUNW_UNWIND .eh_frame_hdr sections instead of
280	 PT_SUNW_EH_FRAME/PT_GNU_EH_FRAME, so accept them as well.  */
281      else if (phdr->p_type == PT_SUNW_UNWIND)
282	p_eh_frame_hdr = phdr;
283#endif
284      else if (phdr->p_type == PT_DYNAMIC)
285	p_dynamic = phdr;
286    }
287
288  if (!match)
289    return 0;
290
291  if (size >= sizeof (struct ext_dl_phdr_info))
292    {
293      /* Move the cache entry we're about to overwrite to the head of
294	 the list.  If either last_cache_entry or prev_cache_entry are
295	 NULL, that cache entry is already at the head.  */
296      if (last_cache_entry != NULL && prev_cache_entry != NULL)
297	{
298	  prev_cache_entry->link = last_cache_entry->link;
299	  last_cache_entry->link = frame_hdr_cache_head;
300	  frame_hdr_cache_head = last_cache_entry;
301	}
302
303      frame_hdr_cache_head->load_base = load_base;
304      frame_hdr_cache_head->p_eh_frame_hdr = p_eh_frame_hdr;
305      frame_hdr_cache_head->p_dynamic = p_dynamic;
306      frame_hdr_cache_head->pc_low = pc_low;
307      frame_hdr_cache_head->pc_high = pc_high;
308    }
309
310 found:
311
312  if (!p_eh_frame_hdr)
313    return 0;
314
315  /* Read .eh_frame_hdr header.  */
316  hdr = (const struct unw_eh_frame_hdr *)
317    __RELOC_POINTER (p_eh_frame_hdr->p_vaddr, load_base);
318  if (hdr->version != 1)
319    return 1;
320
321#ifdef CRT_GET_RFIB_DATA
322# ifdef __i386__
323  data->dbase = NULL;
324  if (p_dynamic)
325    {
326      /* For dynamically linked executables and shared libraries,
327	 DT_PLTGOT is the gp value for that object.  */
328      ElfW(Dyn) *dyn = (ElfW(Dyn) *)
329	__RELOC_POINTER (p_dynamic->p_vaddr, load_base);
330      for (; dyn->d_tag != DT_NULL ; dyn++)
331	if (dyn->d_tag == DT_PLTGOT)
332	  {
333	    data->dbase = (void *) dyn->d_un.d_ptr;
334#if defined __linux__
335	    /* On IA-32 Linux, _DYNAMIC is writable and GLIBC has
336	       relocated it.  */
337#elif defined __sun__ && defined __svr4__
338	    /* On Solaris 2/x86, we need to do this ourselves.  */
339	    data->dbase += load_base;
340#endif
341	    break;
342	  }
343    }
344# elif defined __FRV_FDPIC__ && defined __linux__
345  data->dbase = load_base.got_value;
346# else
347#  error What is DW_EH_PE_datarel base on this platform?
348# endif
349#endif
350
351  p = read_encoded_value_with_base (hdr->eh_frame_ptr_enc,
352				    base_from_cb_data (hdr->eh_frame_ptr_enc,
353						       data),
354				    (const unsigned char *) (hdr + 1),
355				    &eh_frame);
356
357  /* We require here specific table encoding to speed things up.
358     Also, DW_EH_PE_datarel here means using PT_GNU_EH_FRAME start
359     as base, not the processor specific DW_EH_PE_datarel.  */
360  if (hdr->fde_count_enc != DW_EH_PE_omit
361      && hdr->table_enc == (DW_EH_PE_datarel | DW_EH_PE_sdata4))
362    {
363      _Unwind_Ptr fde_count;
364
365      p = read_encoded_value_with_base (hdr->fde_count_enc,
366					base_from_cb_data (hdr->fde_count_enc,
367							   data),
368					p, &fde_count);
369      /* Shouldn't happen.  */
370      if (fde_count == 0)
371	return 1;
372      if ((((_Unwind_Ptr) p) & 3) == 0)
373	{
374	  struct fde_table {
375	    signed initial_loc __attribute__ ((mode (SI)));
376	    signed fde __attribute__ ((mode (SI)));
377	  };
378	  const struct fde_table *table = (const struct fde_table *) p;
379	  size_t lo, hi, mid;
380	  _Unwind_Ptr data_base = (_Unwind_Ptr) hdr;
381	  fde *f;
382	  unsigned int f_enc, f_enc_size;
383	  _Unwind_Ptr range;
384
385	  mid = fde_count - 1;
386	  if (data->pc < table[0].initial_loc + data_base)
387	    return 1;
388	  else if (data->pc < table[mid].initial_loc + data_base)
389	    {
390	      lo = 0;
391	      hi = mid;
392
393	      while (lo < hi)
394		{
395		  mid = (lo + hi) / 2;
396		  if (data->pc < table[mid].initial_loc + data_base)
397		    hi = mid;
398		  else if (data->pc >= table[mid + 1].initial_loc + data_base)
399		    lo = mid + 1;
400		  else
401		    break;
402		}
403
404	      gcc_assert (lo < hi);
405	    }
406
407	  f = (fde *) (table[mid].fde + data_base);
408	  f_enc = get_fde_encoding (f);
409	  f_enc_size = size_of_encoded_value (f_enc);
410	  read_encoded_value_with_base (f_enc & 0x0f, 0,
411					&f->pc_begin[f_enc_size], &range);
412	  if (data->pc < table[mid].initial_loc + data_base + range)
413	    data->ret = f;
414	  data->func = (void *) (table[mid].initial_loc + data_base);
415	  return 1;
416	}
417    }
418
419  /* We have no sorted search table, so need to go the slow way.
420     As soon as GLIBC will provide API so to notify that a library has been
421     removed, we could cache this (and thus use search_object).  */
422  ob.pc_begin = NULL;
423  ob.tbase = data->tbase;
424  ob.dbase = data->dbase;
425  ob.u.single = (fde *) eh_frame;
426  ob.s.i = 0;
427  ob.s.b.mixed_encoding = 1;  /* Need to assume worst case.  */
428  data->ret = linear_search_fdes (&ob, (fde *) eh_frame, (void *) data->pc);
429  if (data->ret != NULL)
430    {
431      _Unwind_Ptr func;
432      unsigned int encoding = get_fde_encoding (data->ret);
433
434      read_encoded_value_with_base (encoding,
435				    base_from_cb_data (encoding, data),
436				    data->ret->pc_begin, &func);
437      data->func = (void *) func;
438    }
439  return 1;
440}
441
442const fde *
443_Unwind_Find_FDE (void *pc, struct dwarf_eh_bases *bases)
444{
445  struct unw_eh_callback_data data;
446  const fde *ret;
447
448  ret = _Unwind_Find_registered_FDE (pc, bases);
449  if (ret != NULL)
450    return ret;
451
452  data.pc = (_Unwind_Ptr) pc;
453  data.tbase = NULL;
454  data.dbase = NULL;
455  data.func = NULL;
456  data.ret = NULL;
457  data.check_cache = 1;
458
459  if (dl_iterate_phdr (_Unwind_IteratePhdrCallback, &data) < 0)
460    return NULL;
461
462  if (data.ret)
463    {
464      bases->tbase = data.tbase;
465      bases->dbase = data.dbase;
466      bases->func = data.func;
467    }
468  return data.ret;
469}
470
471#else
472/* Prevent multiple include of header files.  */
473#define _Unwind_Find_FDE _Unwind_Find_FDE
474#include "unwind-dw2-fde.c"
475#endif
476
477#if defined (USE_GAS_SYMVER) && defined (SHARED) && defined (USE_LIBUNWIND_EXCEPTIONS)
478alias (_Unwind_Find_FDE);
479#endif
480