LCOV - code coverage report
Current view: top level - libdwfl - derelocate.c (source / functions) Hit Total Coverage
Test: elfutils-0.173 Lines: 131 163 80.4 %
Date: 2018-06-29 23:49:12 Functions: 9 9 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* Recover relocatibility for addresses computed from debug information.
       2             :    Copyright (C) 2005-2010, 2013, 2015 Red Hat, Inc.
       3             :    This file is part of elfutils.
       4             : 
       5             :    This file is free software; you can redistribute it and/or modify
       6             :    it under the terms of either
       7             : 
       8             :      * the GNU Lesser General Public License as published by the Free
       9             :        Software Foundation; either version 3 of the License, or (at
      10             :        your option) any later version
      11             : 
      12             :    or
      13             : 
      14             :      * the GNU General Public License as published by the Free
      15             :        Software Foundation; either version 2 of the License, or (at
      16             :        your option) any later version
      17             : 
      18             :    or both in parallel, as here.
      19             : 
      20             :    elfutils is distributed in the hope that it will be useful, but
      21             :    WITHOUT ANY WARRANTY; without even the implied warranty of
      22             :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      23             :    General Public License for more details.
      24             : 
      25             :    You should have received copies of the GNU General Public License and
      26             :    the GNU Lesser General Public License along with this program.  If
      27             :    not, see <http://www.gnu.org/licenses/>.  */
      28             : 
      29             : #ifdef HAVE_CONFIG_H
      30             : # include <config.h>
      31             : #endif
      32             : 
      33             : #include "libdwflP.h"
      34             : 
      35             : struct dwfl_relocation
      36             : {
      37             :   size_t count;
      38             :   struct
      39             :   {
      40             :     Elf_Scn *scn;
      41             :     Elf_Scn *relocs;
      42             :     const char *name;
      43             :     GElf_Addr start, end;
      44             :   } refs[0];
      45             : };
      46             : 
      47             : 
      48             : struct secref
      49             : {
      50             :   struct secref *next;
      51             :   Elf_Scn *scn;
      52             :   Elf_Scn *relocs;
      53             :   const char *name;
      54             :   GElf_Addr start, end;
      55             : };
      56             : 
      57             : static int
      58        5627 : compare_secrefs (const void *a, const void *b)
      59             : {
      60        5627 :   struct secref *const *p1 = a;
      61        5627 :   struct secref *const *p2 = b;
      62             : 
      63             :   /* No signed difference calculation is correct here, since the
      64             :      terms are unsigned and could be more than INT64_MAX apart.  */
      65        5627 :   if ((*p1)->start < (*p2)->start)
      66             :     return -1;
      67          51 :   if ((*p1)->start > (*p2)->start)
      68             :     return 1;
      69             : 
      70          51 :   if ((*p1)->end < (*p2)->end)
      71             :     return -1;
      72          22 :   if ((*p1)->end > (*p2)->end)
      73             :     return 1;
      74             : 
      75             :   /* Same start/end, then just compare which section came first.  */
      76          10 :   return elf_ndxscn ((*p1)->scn) - elf_ndxscn ((*p2)->scn);
      77             : }
      78             : 
      79             : static int
      80      248834 : cache_sections (Dwfl_Module *mod)
      81             : {
      82      246138 :   if (likely (mod->reloc_info != NULL))
      83      246001 :     return mod->reloc_info->count;
      84             : 
      85         137 :   struct secref *refs = NULL;
      86         137 :   size_t nrefs = 0;
      87             : 
      88             :   size_t shstrndx;
      89         137 :   if (unlikely (elf_getshdrstrndx (mod->main.elf, &shstrndx) < 0))
      90             :     {
      91             :     elf_error:
      92           0 :       __libdwfl_seterrno (DWFL_E_LIBELF);
      93           0 :       nrefs = -1;
      94           0 :       goto free_refs;
      95             :     }
      96             : 
      97             :   bool check_reloc_sections = false;
      98             :   Elf_Scn *scn = NULL;
      99        4296 :   while ((scn = elf_nextscn (mod->main.elf, scn)) != NULL)
     100             :     {
     101             :       GElf_Shdr shdr_mem;
     102        4159 :       GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
     103        4159 :       if (shdr == NULL)
     104             :         goto elf_error;
     105             : 
     106        4159 :       if ((shdr->sh_flags & SHF_ALLOC) && shdr->sh_addr == 0
     107          41 :           && mod->e_type == ET_REL)
     108             :         {
     109             :           /* This section might not yet have been looked at.  */
     110          40 :           if (__libdwfl_relocate_value (mod, mod->main.elf, &shstrndx,
     111          40 :                                         elf_ndxscn (scn),
     112          40 :                                         &shdr->sh_addr) != DWFL_E_NOERROR)
     113           0 :             continue;
     114          40 :           shdr = gelf_getshdr (scn, &shdr_mem);
     115          40 :           if (unlikely (shdr == NULL))
     116             :             goto elf_error;
     117             :         }
     118             : 
     119        4159 :       if (shdr->sh_flags & SHF_ALLOC)
     120             :         {
     121        2696 :           const char *name = elf_strptr (mod->main.elf, shstrndx,
     122        2696 :                                          shdr->sh_name);
     123        2696 :           if (unlikely (name == NULL))
     124             :             goto elf_error;
     125             : 
     126        2696 :           struct secref *newref = malloc (sizeof *newref);
     127        2696 :           if (unlikely (newref == NULL))
     128             :             {
     129             :             nomem:
     130           0 :               __libdwfl_seterrno (DWFL_E_NOMEM);
     131           0 :               nrefs = -1;
     132           0 :               goto free_refs;
     133             :             }
     134             : 
     135        2696 :           newref->scn = scn;
     136        2696 :           newref->relocs = NULL;
     137        2696 :           newref->name = name;
     138        8088 :           newref->start = dwfl_adjusted_address (mod, shdr->sh_addr);
     139        2696 :           newref->end = newref->start + shdr->sh_size;
     140        2696 :           newref->next = refs;
     141        2696 :           refs = newref;
     142        2696 :           ++nrefs;
     143             :         }
     144             : 
     145        4159 :       if (mod->e_type == ET_REL
     146        1010 :           && shdr->sh_size != 0
     147         791 :           && (shdr->sh_type == SHT_REL || shdr->sh_type == SHT_RELA)
     148          72 :           && mod->dwfl->callbacks->section_address != NULL)
     149             :         {
     150          72 :           if (shdr->sh_info < elf_ndxscn (scn))
     151             :             {
     152             :               /* We've already looked at the section these relocs apply to.  */
     153          72 :               Elf_Scn *tscn = elf_getscn (mod->main.elf, shdr->sh_info);
     154          72 :               if (likely (tscn != NULL))
     155           0 :                 for (struct secref *sec = refs; sec != NULL; sec = sec->next)
     156          72 :                   if (sec->scn == tscn)
     157             :                     {
     158          72 :                       sec->relocs = scn;
     159          72 :                       break;
     160             :                     }
     161             :             }
     162             :           else
     163             :             /* We'll have to do a second pass.  */
     164             :             check_reloc_sections = true;
     165             :         }
     166             :     }
     167             : 
     168         137 :   mod->reloc_info = malloc (offsetof (struct dwfl_relocation, refs[nrefs]));
     169         137 :   if (unlikely (mod->reloc_info == NULL))
     170             :     goto nomem;
     171             : 
     172         137 :   struct secref **sortrefs = malloc (nrefs * sizeof sortrefs[0]);
     173         137 :   if (unlikely (sortrefs == NULL))
     174             :     goto nomem;
     175             : 
     176        2696 :   for (size_t i = nrefs; i-- > 0; refs = refs->next)
     177        2696 :     sortrefs[i] = refs;
     178         137 :   assert (refs == NULL);
     179             : 
     180         137 :   qsort (sortrefs, nrefs, sizeof sortrefs[0], &compare_secrefs);
     181             : 
     182         137 :   mod->reloc_info->count = nrefs;
     183        2833 :   for (size_t i = 0; i < nrefs; ++i)
     184             :     {
     185        2696 :       mod->reloc_info->refs[i].name = sortrefs[i]->name;
     186        2696 :       mod->reloc_info->refs[i].scn = sortrefs[i]->scn;
     187        2696 :       mod->reloc_info->refs[i].relocs = sortrefs[i]->relocs;
     188        2696 :       mod->reloc_info->refs[i].start = sortrefs[i]->start;
     189        2696 :       mod->reloc_info->refs[i].end = sortrefs[i]->end;
     190        2696 :       free (sortrefs[i]);
     191             :     }
     192             : 
     193         137 :   free (sortrefs);
     194             : 
     195         137 :   if (unlikely (check_reloc_sections))
     196             :     {
     197             :       /* There was a reloc section that preceded its target section.
     198             :          So we have to scan again now that we have cached all the
     199             :          possible target sections we care about.  */
     200             : 
     201             :       scn = NULL;
     202           0 :       while ((scn = elf_nextscn (mod->main.elf, scn)) != NULL)
     203             :         {
     204             :           GElf_Shdr shdr_mem;
     205           0 :           GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
     206           0 :           if (shdr == NULL)
     207             :             goto elf_error;
     208             : 
     209           0 :           if (shdr->sh_size != 0
     210           0 :               && (shdr->sh_type == SHT_REL || shdr->sh_type == SHT_RELA))
     211             :             {
     212           0 :               Elf_Scn *tscn = elf_getscn (mod->main.elf, shdr->sh_info);
     213           0 :               if (likely (tscn != NULL))
     214           0 :                 for (size_t i = 0; i < nrefs; ++i)
     215           0 :                   if (mod->reloc_info->refs[i].scn == tscn)
     216             :                     {
     217           0 :                       mod->reloc_info->refs[i].relocs = scn;
     218           0 :                       break;
     219             :                     }
     220             :             }
     221             :         }
     222             :     }
     223             : 
     224             : free_refs:
     225         137 :   while (refs != NULL)
     226             :     {
     227           0 :       struct secref *ref = refs;
     228           0 :       refs = ref->next;
     229           0 :       free (ref);
     230             :     }
     231             : 
     232         137 :   return nrefs;
     233             : }
     234             : 
     235             : 
     236             : int
     237      585260 : dwfl_module_relocations (Dwfl_Module *mod)
     238             : {
     239      585260 :   if (mod == NULL)
     240             :     return -1;
     241             : 
     242      585260 :   switch (mod->e_type)
     243             :     {
     244             :     case ET_REL:
     245       43446 :       return cache_sections (mod);
     246             : 
     247             :     case ET_DYN:
     248             :       return 1;
     249             : 
     250             :     case ET_EXEC:
     251      395335 :       assert (mod->main.vaddr == mod->low_addr);
     252             :       break;
     253             :     }
     254             : 
     255      395335 :   return 0;
     256             : }
     257             : 
     258             : const char *
     259      189934 : dwfl_module_relocation_info (Dwfl_Module *mod, unsigned int idx,
     260             :                              Elf32_Word *shndxp)
     261             : {
     262      189934 :   if (mod == NULL)
     263             :     return NULL;
     264             : 
     265      189934 :   switch (mod->e_type)
     266             :     {
     267             :     case ET_REL:
     268             :       break;
     269             : 
     270             :     case ET_DYN:
     271      146481 :       if (idx != 0)
     272             :         return NULL;
     273      146481 :       if (shndxp)
     274           0 :         *shndxp = SHN_ABS;
     275             :       return "";
     276             : 
     277             :     default:
     278             :       return NULL;
     279             :     }
     280             : 
     281       43453 :   if (cache_sections (mod) < 0)
     282             :     return NULL;
     283             : 
     284       43453 :   struct dwfl_relocation *sections = mod->reloc_info;
     285             : 
     286       43453 :   if (idx >= sections->count)
     287             :     return NULL;
     288             : 
     289       43453 :   if (shndxp)
     290           0 :     *shndxp = elf_ndxscn (sections->refs[idx].scn);
     291             : 
     292       43453 :   return sections->refs[idx].name;
     293             : }
     294             : 
     295             : /* Check that MOD is valid and make sure its relocation has been done.  */
     296             : static bool
     297      190189 : check_module (Dwfl_Module *mod)
     298             : {
     299      190189 :   if (mod == NULL)
     300             :     return true;
     301             : 
     302      190189 :   if (INTUSE(dwfl_module_getsymtab) (mod) < 0)
     303             :     {
     304           0 :       Dwfl_Error error = dwfl_errno ();
     305           0 :       if (error != DWFL_E_NO_SYMTAB)
     306             :         {
     307           0 :           __libdwfl_seterrno (error);
     308           0 :           return true;
     309             :         }
     310             :     }
     311             : 
     312      190189 :   if (mod->dw == NULL)
     313             :     {
     314             :       Dwarf_Addr bias;
     315         177 :       if (INTUSE(dwfl_module_getdwarf) (mod, &bias) == NULL)
     316             :         {
     317         166 :           Dwfl_Error error = dwfl_errno ();
     318         166 :           if (error != DWFL_E_NO_DWARF)
     319             :             {
     320           0 :               __libdwfl_seterrno (error);
     321           0 :               return true;
     322             :             }
     323             :         }
     324             :     }
     325             : 
     326             :   return false;
     327             : }
     328             : 
     329             : /* Find the index in MOD->reloc_info.refs containing *ADDR.  */
     330             : static int
     331      159239 : find_section (Dwfl_Module *mod, Dwarf_Addr *addr)
     332             : {
     333      159239 :   if (cache_sections (mod) < 0)
     334             :     return -1;
     335             : 
     336      159239 :   struct dwfl_relocation *sections = mod->reloc_info;
     337             : 
     338             :   /* The sections are sorted by address, so we can use binary search.  */
     339      159239 :   size_t l = 0, u = sections->count;
     340      788373 :   while (l < u)
     341             :     {
     342      629125 :       size_t idx = (l + u) / 2;
     343      629125 :       if (*addr < sections->refs[idx].start)
     344             :         u = idx;
     345      378534 :       else if (*addr > sections->refs[idx].end)
     346      219304 :         l = idx + 1;
     347             :       else
     348             :         {
     349             :           /* Consider the limit of a section to be inside it, unless it's
     350             :              inside the next one.  A section limit address can appear in
     351             :              line records.  */
     352      159230 :           if (*addr == sections->refs[idx].end
     353        3390 :               && idx + 1 < sections->count
     354        3389 :               && *addr == sections->refs[idx + 1].start)
     355        3352 :             ++idx;
     356             : 
     357      159230 :           *addr -= sections->refs[idx].start;
     358      159230 :           return idx;
     359             :         }
     360             :     }
     361             : 
     362           9 :   __libdwfl_seterrno (DWFL_E (LIBDW, DWARF_E_NO_MATCH));
     363           9 :   return -1;
     364             : }
     365             : 
     366             : size_t
     367             : internal_function
     368      115708 : __libdwfl_find_section_ndx (Dwfl_Module *mod, Dwarf_Addr *addr)
     369             : {
     370      115708 :   int idx = find_section (mod, addr);
     371      115708 :   if (unlikely (idx == -1))
     372             :     return SHN_UNDEF;
     373             : 
     374      115699 :   return elf_ndxscn (mod->reloc_info->refs[idx].scn);
     375             : }
     376             : 
     377             : int
     378      190115 : dwfl_module_relocate_address (Dwfl_Module *mod, Dwarf_Addr *addr)
     379             : {
     380      190115 :   if (unlikely (check_module (mod)))
     381             :     return -1;
     382             : 
     383      190115 :   switch (mod->e_type)
     384             :     {
     385             :     case ET_REL:
     386       43457 :       return find_section (mod, addr);
     387             : 
     388             :     case ET_DYN:
     389             :       /* All relative to first and only relocation base: module start.  */
     390      146642 :       *addr -= mod->low_addr;
     391      146642 :       break;
     392             : 
     393             :     default:
     394             :       /* Already absolute, dwfl_module_relocations returned zero.  We
     395             :          shouldn't really have been called, but it's a harmless no-op.  */
     396             :       break;
     397             :     }
     398             : 
     399             :   return 0;
     400             : }
     401             : INTDEF (dwfl_module_relocate_address)
     402             : 
     403             : Elf_Scn *
     404         148 : dwfl_module_address_section (Dwfl_Module *mod, Dwarf_Addr *address,
     405             :                              Dwarf_Addr *bias)
     406             : {
     407          74 :   if (check_module (mod))
     408             :     return NULL;
     409             : 
     410          74 :   int idx = find_section (mod, address);
     411          74 :   if (idx < 0)
     412             :     return NULL;
     413             : 
     414          74 :   if (mod->reloc_info->refs[idx].relocs != NULL)
     415             :     {
     416           2 :       assert (mod->e_type == ET_REL);
     417             : 
     418           2 :       Elf_Scn *tscn = mod->reloc_info->refs[idx].scn;
     419           2 :       Elf_Scn *relocscn = mod->reloc_info->refs[idx].relocs;
     420           2 :       Dwfl_Error result = __libdwfl_relocate_section (mod, mod->main.elf,
     421             :                                                       relocscn, tscn, true);
     422           2 :       if (likely (result == DWFL_E_NOERROR))
     423           2 :         mod->reloc_info->refs[idx].relocs = NULL;
     424             :       else
     425             :         {
     426           0 :           __libdwfl_seterrno (result);
     427           0 :           return NULL;
     428             :         }
     429             :     }
     430             : 
     431          74 :   *bias = dwfl_adjusted_address (mod, 0);
     432          74 :   return mod->reloc_info->refs[idx].scn;
     433             : }
     434             : INTDEF (dwfl_module_address_section)

Generated by: LCOV version 1.13