Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  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.  
  87. static 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.  
  97. struct 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.  
  107. struct 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.  
  117. static 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.  
  127. static 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.  
  132. static _Unwind_Ptr
  133. base_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.  
  154. static 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.  
  442. const 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)
  478. alias (_Unwind_Find_FDE);
  479. #endif
  480.