libdwfl/relocate.c

   1 /* Relocate debug information.
   2    Copyright (C) 2005-2011, 2014 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 #include "libdwflP.h"
  30
  31 typedef uint8_t GElf_Byte;
  32
  33 /* Adjust *VALUE to add the load address of the SHNDX section.
  34    We update the section header in place to cache the result.  */
  35
  36 Dwfl_Error
  37 internal_function
  38 __libdwfl_relocate_value (Dwfl_Module *mod, Elf *elf, size_t *shstrndx,
  39                           Elf32_Word shndx, GElf_Addr *value)
  40 {
  41   /* No adjustment needed for section zero, it is never loaded.
  42      Handle it first, just in case the ELF file has strange section
  43      zero flags set.  */
  44   if (shndx == 0)
  45     return DWFL_E_NOERROR;
  46
  47   Elf_Scn *refscn = elf_getscn (elf, shndx);
  48   GElf_Shdr refshdr_mem, *refshdr = gelf_getshdr (refscn, &refshdr_mem);
  49   if (refshdr == NULL)
  50     return DWFL_E_LIBELF;
  51
  52   if (refshdr->sh_addr == 0 && (refshdr->sh_flags & SHF_ALLOC))
  53     {
  54       /* This is a loaded section.  Find its actual
  55          address and update the section header.  */
  56
  57       if (*shstrndx == SHN_UNDEF
  58           && unlikely (elf_getshdrstrndx (elf, shstrndx) < 0))
  59         return DWFL_E_LIBELF;
  60
  61       const char *name = elf_strptr (elf, *shstrndx, refshdr->sh_name);
  62       if (unlikely (name == NULL))
  63         return DWFL_E_LIBELF;
  64
  65       if ((*mod->dwfl->callbacks->section_address) (MODCB_ARGS (mod),
  66                                                     name, shndx, refshdr,
  67                                                     &refshdr->sh_addr))
  68         return CBFAIL;
  69
  70       if (refshdr->sh_addr == (Dwarf_Addr) -1l)
  71         /* The callback indicated this section wasn't really loaded but we
  72            don't really care.  */
  73         refshdr->sh_addr = 0;   /* Make no adjustment below.  */
  74
  75       /* Update the in-core file's section header to show the final
  76          load address (or unloadedness).  This serves as a cache,
  77          so we won't get here again for the same section.  */
  78       if (likely (refshdr->sh_addr != 0)
  79           && unlikely (! gelf_update_shdr (refscn, refshdr)))
  80         return DWFL_E_LIBELF;
  81     }
  82
  83   if (refshdr->sh_flags & SHF_ALLOC)
  84     /* Apply the adjustment.  */
  85     *value += dwfl_adjusted_address (mod, refshdr->sh_addr);
  86
  87   return DWFL_E_NOERROR;
  88 }
  89
  90
  91 /* Cache used by relocate_getsym.  */
  92 struct reloc_symtab_cache
  93 {
  94   Elf *symelf;
  95   Elf_Data *symdata;
  96   Elf_Data *symxndxdata;
  97   Elf_Data *symstrdata;
  98   size_t symshstrndx;
  99   size_t strtabndx;
 100 };
 101 #define RELOC_SYMTAB_CACHE(cache)       \
 102   struct reloc_symtab_cache cache =     \
 103     { NULL, NULL, NULL, NULL, SHN_UNDEF, SHN_UNDEF }
 104
 105 /* This is just doing dwfl_module_getsym, except that we must always use
 106    the symbol table in RELOCATED itself when it has one, not MOD->symfile.  */
 107 static Dwfl_Error
 108 relocate_getsym (Dwfl_Module *mod,
 109                  Elf *relocated, struct reloc_symtab_cache *cache,
 110                  int symndx, GElf_Sym *sym, GElf_Word *shndx)
 111 {
 112   if (cache->symdata == NULL)
 113     {
 114       if (mod->symfile == NULL || mod->symfile->elf != relocated)
 115         {
 116           /* We have to look up the symbol table in the file we are
 117              relocating, if it has its own.  These reloc sections refer to
 118              the symbol table in this file, and a symbol table in the main
 119              file might not match.  However, some tools did produce ET_REL
 120              .debug files with relocs but no symtab of their own.  */
 121           Elf_Scn *scn = NULL;
 122           while ((scn = elf_nextscn (relocated, scn)) != NULL)
 123             {
 124               GElf_Shdr shdr_mem, *shdr = gelf_getshdr (scn, &shdr_mem);
 125               if (shdr != NULL)
 126                 {
 127                   /* We need uncompressed data.  */
 128                   if ((shdr->sh_type == SHT_SYMTAB
 129                        || shdr->sh_type == SHT_SYMTAB_SHNDX)
 130                       && (shdr->sh_flags & SHF_COMPRESSED) != 0)
 131                     if (elf_compress (scn, 0, 0) < 0)
 132                       return DWFL_E_LIBELF;
 133
 134                   switch (shdr->sh_type)
 135                     {
 136                     default:
 137                       continue;
 138                     case SHT_SYMTAB:
 139                       cache->symelf = relocated;
 140                       cache->symdata = elf_getdata (scn, NULL);
 141                       cache->strtabndx = shdr->sh_link;
 142                       if (unlikely (cache->symdata == NULL))
 143                         return DWFL_E_LIBELF;
 144                       break;
 145                     case SHT_SYMTAB_SHNDX:
 146                       cache->symxndxdata = elf_getdata (scn, NULL);
 147                       if (unlikely (cache->symxndxdata == NULL))
 148                         return DWFL_E_LIBELF;
 149                       break;
 150                     }
 151                 }
 152               if (cache->symdata != NULL && cache->symxndxdata != NULL)
 153                 break;
 154             }
 155         }
 156       if (cache->symdata == NULL)
 157         {
 158           /* We might not have looked for a symbol table file yet,
 159              when coming from __libdwfl_relocate_section.  */
 160           if (unlikely (mod->symfile == NULL)
 161               && unlikely (INTUSE(dwfl_module_getsymtab) (mod) < 0))
 162             return dwfl_errno ();
 163
 164           /* The symbol table we have already cached is the one from
 165              the file being relocated, so it's what we need.  Or else
 166              this is an ET_REL .debug file with no .symtab of its own;
 167              the symbols refer to the section indices in the main file.  */
 168           cache->symelf = mod->symfile->elf;
 169           cache->symdata = mod->symdata;
 170           cache->symxndxdata = mod->symxndxdata;
 171           cache->symstrdata = mod->symstrdata;
 172         }
 173     }
 174
 175   if (unlikely (gelf_getsymshndx (cache->symdata, cache->symxndxdata,
 176                                   symndx, sym, shndx) == NULL))
 177     return DWFL_E_LIBELF;
 178
 179   if (sym->st_shndx != SHN_XINDEX)
 180     *shndx = sym->st_shndx;
 181
 182   switch (sym->st_shndx)
 183     {
 184     case SHN_ABS:
 185     case SHN_UNDEF:
 186       return DWFL_E_NOERROR;
 187
 188     case SHN_COMMON:
 189       sym->st_value = 0;        /* Value is size, not helpful. */
 190       return DWFL_E_NOERROR;
 191     }
 192
 193   return __libdwfl_relocate_value (mod, cache->symelf, &cache->symshstrndx,
 194                                    *shndx, &sym->st_value);
 195 }
 196
 197 /* Handle an undefined symbol.  We really only support ET_REL for Linux
 198    kernel modules, and offline archives.  The behavior of the Linux module
 199    loader is very simple and easy to mimic.  It only matches magically
 200    exported symbols, and we match any defined symbols.  But we get the same
 201    answer except when the module's symbols are undefined and would prevent
 202    it from being loaded.  */
 203 static Dwfl_Error
 204 resolve_symbol (Dwfl_Module *referer, struct reloc_symtab_cache *symtab,
 205                 GElf_Sym *sym, GElf_Word shndx)
 206 {
 207   /* First we need its name.  */
 208   if (sym->st_name != 0)
 209     {
 210       if (symtab->symstrdata == NULL)
 211         {
 212           /* Cache the strtab for this symtab.  */
 213           assert (referer->symfile == NULL
 214                   || referer->symfile->elf != symtab->symelf);
 215
 216           Elf_Scn *scn = elf_getscn (symtab->symelf, symtab->strtabndx);
 217           if (scn == NULL)
 218             return DWFL_E_LIBELF;
 219
 220           GElf_Shdr shdr_mem;
 221           GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
 222           if (shdr == NULL)
 223             return DWFL_E_LIBELF;
 224
 225           if (symtab->symshstrndx == SHN_UNDEF
 226               && elf_getshdrstrndx (symtab->symelf, &symtab->symshstrndx) < 0)
 227             return DWFL_E_LIBELF;
 228
 229           const char *sname = elf_strptr (symtab->symelf, symtab->symshstrndx,
 230                                           shdr->sh_name);
 231           if (sname == NULL)
 232             return DWFL_E_LIBELF;
 233
 234           /* If the section is already decompressed, that isn't an error.  */
 235           if (strncmp (sname, ".zdebug", strlen (".zdebug")) == 0)
 236             elf_compress_gnu (scn, 0, 0);
 237
 238           if ((shdr->sh_flags & SHF_COMPRESSED) != 0)
 239             if (elf_compress (scn, 0, 0) < 0)
 240               return DWFL_E_LIBELF;
 241
 242           symtab->symstrdata = elf_getdata (scn, NULL);
 243           if (unlikely (symtab->symstrdata == NULL
 244                         || symtab->symstrdata->d_buf == NULL))
 245             return DWFL_E_LIBELF;
 246         }
 247       if (unlikely (sym->st_name >= symtab->symstrdata->d_size))
 248         return DWFL_E_BADSTROFF;
 249
 250       const char *name = symtab->symstrdata->d_buf;
 251       name += sym->st_name;
 252
 253       for (Dwfl_Module *m = referer->dwfl->modulelist; m != NULL; m = m->next)
 254         if (m != referer)
 255           {
 256             /* Get this module's symtab.
 257                If we got a fresh error reading the table, report it.
 258                If we just have no symbols in this module, no harm done.  */
 259             if (m->symdata == NULL
 260                 && m->symerr == DWFL_E_NOERROR
 261                 && INTUSE(dwfl_module_getsymtab) (m) < 0
 262                 && m->symerr != DWFL_E_NO_SYMTAB)
 263               return m->symerr;
 264
 265             for (size_t ndx = 1; ndx < m->syments; ++ndx)
 266               {
 267                 sym = gelf_getsymshndx (m->symdata, m->symxndxdata,
 268                                         ndx, sym, &shndx);
 269                 if (unlikely (sym == NULL))
 270                   return DWFL_E_LIBELF;
 271                 if (sym->st_shndx != SHN_XINDEX)
 272                   shndx = sym->st_shndx;
 273
 274                 /* We are looking for a defined global symbol with a name.  */
 275                 if (shndx == SHN_UNDEF || shndx == SHN_COMMON
 276                     || GELF_ST_BIND (sym->st_info) == STB_LOCAL
 277                     || sym->st_name == 0)
 278                   continue;
 279
 280                 /* Get this candidate symbol's name.  */
 281                 if (unlikely (sym->st_name >= m->symstrdata->d_size))
 282                   return DWFL_E_BADSTROFF;
 283                 const char *n = m->symstrdata->d_buf;
 284                 n += sym->st_name;
 285
 286                 /* Does the name match?  */
 287                 if (strcmp (name, n))
 288                   continue;
 289
 290                 /* We found it!  */
 291                 if (shndx == SHN_ABS) /* XXX maybe should apply bias? */
 292                   return DWFL_E_NOERROR;
 293
 294                 if (m->e_type != ET_REL)
 295                   {
 296                     sym->st_value = dwfl_adjusted_st_value (m, m->symfile->elf,
 297                                                             sym->st_value);
 298                     return DWFL_E_NOERROR;
 299                   }
 300
 301                 /* In an ET_REL file, the symbol table values are relative
 302                    to the section, not to the module's load base.  */
 303                 size_t symshstrndx = SHN_UNDEF;
 304                 return __libdwfl_relocate_value (m, m->symfile->elf,
 305                                                  &symshstrndx,
 306                                                  shndx, &sym->st_value);
 307               }
 308           }
 309     }
 310
 311   return DWFL_E_RELUNDEF;
 312 }
 313
 314 /* Apply one relocation.  Returns true for any invalid data.  */
 315 static Dwfl_Error
 316 relocate (Dwfl_Module * const mod,
 317           Elf * const relocated,
 318           struct reloc_symtab_cache * const reloc_symtab,
 319           Elf_Data * const tdata,
 320           const GElf_Ehdr * const ehdr,
 321           GElf_Addr offset,
 322           const GElf_Sxword *addend,
 323           int rtype,
 324           int symndx)
 325 {
 326     /* First see if this is a reloc we can handle.
 327        If we are skipping it, don't bother resolving the symbol.  */
 328
 329     if (unlikely (rtype == 0))
 330       /* In some odd situations, the linker can leave R_*_NONE relocs
 331          behind.  This is probably bogus ld -r behavior, but the only
 332          cases it's known to appear in are harmless: DWARF data
 333          referring to addresses in a section that has been discarded.
 334          So we just pretend it's OK without further relocation.  */
 335       return DWFL_E_NOERROR;
 336
 337     Elf_Type type = ebl_reloc_simple_type (mod->ebl, rtype);
 338     if (unlikely (type == ELF_T_NUM))
 339       return DWFL_E_BADRELTYPE;
 340
 341     /* First, resolve the symbol to an absolute value.  */
 342     GElf_Addr value;
 343
 344     if (symndx == STN_UNDEF)
 345       /* When strip removes a section symbol referring to a
 346          section moved into the debuginfo file, it replaces
 347          that symbol index in relocs with STN_UNDEF.  We
 348          don't actually need the symbol, because those relocs
 349          are always references relative to the nonallocated
 350          debugging sections, which start at zero.  */
 351       value = 0;
 352     else
 353       {
 354         GElf_Sym sym;
 355         GElf_Word shndx;
 356         Dwfl_Error error = relocate_getsym (mod, relocated, reloc_symtab,
 357                                             symndx, &sym, &shndx);
 358         if (unlikely (error != DWFL_E_NOERROR))
 359           return error;
 360
 361         if (shndx == SHN_UNDEF || shndx == SHN_COMMON)
 362           {
 363             /* Maybe we can figure it out anyway.  */
 364             error = resolve_symbol (mod, reloc_symtab, &sym, shndx);
 365             if (error != DWFL_E_NOERROR
 366                 && !(error == DWFL_E_RELUNDEF && shndx == SHN_COMMON))
 367               return error;
 368           }
 369
 370         value = sym.st_value;
 371       }
 372
 373     /* These are the types we can relocate.  */
 374 #define TYPES           DO_TYPE (BYTE, Byte); DO_TYPE (HALF, Half);     \
 375     DO_TYPE (WORD, Word); DO_TYPE (SWORD, Sword);                       \
 376     DO_TYPE (XWORD, Xword); DO_TYPE (SXWORD, Sxword)
 377     size_t size;
 378     switch (type)
 379       {
 380 #define DO_TYPE(NAME, Name)                     \
 381         case ELF_T_##NAME:                      \
 382           size = sizeof (GElf_##Name);          \
 383         break
 384         TYPES;
 385 #undef DO_TYPE
 386       default:
 387         return DWFL_E_BADRELTYPE;
 388       }
 389
 390     if (offset > tdata->d_size || tdata->d_size - offset < size)
 391       return DWFL_E_BADRELOFF;
 392
 393 #define DO_TYPE(NAME, Name) GElf_##Name Name;
 394     union { TYPES; } tmpbuf;
 395 #undef DO_TYPE
 396     Elf_Data tmpdata =
 397       {
 398         .d_type = type,
 399         .d_buf = &tmpbuf,
 400         .d_size = size,
 401         .d_version = EV_CURRENT,
 402       };
 403     Elf_Data rdata =
 404       {
 405         .d_type = type,
 406         .d_buf = tdata->d_buf + offset,
 407         .d_size = size,
 408         .d_version = EV_CURRENT,
 409       };
 410
 411     /* XXX check for overflow? */
 412     if (addend)
 413       {
 414         /* For the addend form, we have the value already.  */
 415         value += *addend;
 416         switch (type)
 417           {
 418 #define DO_TYPE(NAME, Name)                     \
 419             case ELF_T_##NAME:                  \
 420               tmpbuf.Name = value;              \
 421             break
 422             TYPES;
 423 #undef DO_TYPE
 424           default:
 425             abort ();
 426           }
 427       }
 428     else
 429       {
 430         /* Extract the original value and apply the reloc.  */
 431         Elf_Data *d = gelf_xlatetom (relocated, &tmpdata, &rdata,
 432                                      ehdr->e_ident[EI_DATA]);
 433         if (d == NULL)
 434           return DWFL_E_LIBELF;
 435         assert (d == &tmpdata);
 436         switch (type)
 437           {
 438 #define DO_TYPE(NAME, Name)                             \
 439             case ELF_T_##NAME:                          \
 440               tmpbuf.Name += (GElf_##Name) value;       \
 441             break
 442             TYPES;
 443 #undef DO_TYPE
 444           default:
 445             abort ();
 446           }
 447       }
 448
 449     /* Now convert the relocated datum back to the target
 450        format.  This will write into rdata.d_buf, which
 451        points into the raw section data being relocated.  */
 452     Elf_Data *s = gelf_xlatetof (relocated, &rdata, &tmpdata,
 453                                  ehdr->e_ident[EI_DATA]);
 454     if (s == NULL)
 455       return DWFL_E_LIBELF;
 456     assert (s == &rdata);
 457
 458     /* We have applied this relocation!  */
 459     return DWFL_E_NOERROR;
 460 }
 461
 462 static inline void
 463 check_badreltype (bool *first_badreltype,
 464                   Dwfl_Module *mod,
 465                   Dwfl_Error *result)
 466 {
 467   if (*first_badreltype)
 468     {
 469        *first_badreltype = false;
 470        if (ebl_get_elfmachine (mod->ebl) == EM_NONE)
 471           /* This might be because ebl_openbackend failed to find
 472              any libebl_CPU.so library.  Diagnose that clearly.  */
 473           *result = DWFL_E_UNKNOWN_MACHINE;
 474      }
 475 }
 476
 477 static Dwfl_Error
 478 relocate_section (Dwfl_Module *mod, Elf *relocated, const GElf_Ehdr *ehdr,
 479                   size_t shstrndx, struct reloc_symtab_cache *reloc_symtab,
 480                   Elf_Scn *scn, GElf_Shdr *shdr,
 481                   Elf_Scn *tscn, bool debugscn, bool partial)
 482 {
 483   /* First, fetch the name of the section these relocations apply to.
 484      Then try to decompress both relocation and target section.  */
 485   GElf_Shdr tshdr_mem;
 486   GElf_Shdr *tshdr = gelf_getshdr (tscn, &tshdr_mem);
 487   if (tshdr == NULL)
 488     return DWFL_E_LIBELF;
 489
 490   const char *tname = elf_strptr (relocated, shstrndx, tshdr->sh_name);
 491   if (tname == NULL)
 492     return DWFL_E_LIBELF;
 493
 494   if (debugscn && ! ebl_debugscn_p (mod->ebl, tname))
 495     /* This relocation section is not for a debugging section.
 496        Nothing to do here.  */
 497     return DWFL_E_NOERROR;
 498
 499   if (strncmp (tname, ".zdebug", strlen ("zdebug")) == 0)
 500     elf_compress_gnu (tscn, 0, 0);
 501
 502   if ((tshdr->sh_flags & SHF_COMPRESSED) != 0)
 503     if (elf_compress (tscn, 0, 0) < 0)
 504       return DWFL_E_LIBELF;
 505
 506   /* Reload Shdr in case section was just decompressed.  */
 507   tshdr = gelf_getshdr (tscn, &tshdr_mem);
 508   if (tshdr == NULL)
 509     return DWFL_E_LIBELF;
 510
 511   if (unlikely (tshdr->sh_type == SHT_NOBITS)
 512       || unlikely (tshdr->sh_size == 0))
 513     /* No contents to relocate.  */
 514     return DWFL_E_NOERROR;
 515
 516   const char *sname = elf_strptr (relocated, shstrndx, shdr->sh_name);
 517   if (sname == NULL)
 518     return DWFL_E_LIBELF;
 519
 520   if (strncmp (sname, ".zdebug", strlen ("zdebug")) == 0)
 521     elf_compress_gnu (scn, 0, 0);
 522
 523   if ((shdr->sh_flags & SHF_COMPRESSED) != 0)
 524     if (elf_compress (scn, 0, 0) < 0)
 525       return DWFL_E_LIBELF;
 526
 527   /* Reload Shdr in case section was just decompressed.  */
 528   GElf_Shdr shdr_mem;
 529   shdr = gelf_getshdr (scn, &shdr_mem);
 530   if (shdr == NULL)
 531     return DWFL_E_LIBELF;
 532
 533   /* Fetch the section data that needs the relocations applied.  */
 534   Elf_Data *tdata = elf_rawdata (tscn, NULL);
 535   if (tdata == NULL)
 536     return DWFL_E_LIBELF;
 537
 538   /* If either the section that needs the relocation applied, or the
 539      section that the relocations come from overlap one of the ehdrs,
 540      shdrs or phdrs data then we refuse to do the relocations.  It
 541      isn't illegal for ELF section data to overlap the header data,
 542      but updating the (relocation) data might corrupt the in-memory
 543      libelf headers causing strange corruptions or errors.  */
 544   size_t ehsize = gelf_fsize (relocated, ELF_T_EHDR, 1, EV_CURRENT);
 545   if (unlikely (shdr->sh_offset < ehsize
 546                 || tshdr->sh_offset < ehsize))
 547     return DWFL_E_BADELF;
 548
 549   GElf_Off shdrs_start = ehdr->e_shoff;
 550   size_t shnums;
 551   if (elf_getshdrnum (relocated, &shnums) < 0)
 552     return DWFL_E_LIBELF;
 553   /* Overflows will have been checked by elf_getshdrnum/get|rawdata.  */
 554   size_t shentsize = gelf_fsize (relocated, ELF_T_SHDR, 1, EV_CURRENT);
 555   GElf_Off shdrs_end = shdrs_start + shnums * shentsize;
 556   if (unlikely ((shdrs_start < shdr->sh_offset + shdr->sh_size
 557                  && shdr->sh_offset < shdrs_end)
 558                 || (shdrs_start < tshdr->sh_offset + tshdr->sh_size
 559                     && tshdr->sh_offset < shdrs_end)))
 560     return DWFL_E_BADELF;
 561
 562   GElf_Off phdrs_start = ehdr->e_phoff;
 563   size_t phnums;
 564   if (elf_getphdrnum (relocated, &phnums) < 0)
 565     return DWFL_E_LIBELF;
 566   if (phdrs_start != 0 && phnums != 0)
 567     {
 568       /* Overflows will have been checked by elf_getphdrnum/get|rawdata.  */
 569       size_t phentsize = gelf_fsize (relocated, ELF_T_PHDR, 1, EV_CURRENT);
 570       GElf_Off phdrs_end = phdrs_start + phnums * phentsize;
 571       if (unlikely ((phdrs_start < shdr->sh_offset + shdr->sh_size
 572                      && shdr->sh_offset < phdrs_end)
 573                     || (phdrs_start < tshdr->sh_offset + tshdr->sh_size
 574                         && tshdr->sh_offset < phdrs_end)))
 575         return DWFL_E_BADELF;
 576     }
 577
 578   /* Fetch the relocation section and apply each reloc in it.  */
 579   Elf_Data *reldata = elf_getdata (scn, NULL);
 580   if (reldata == NULL)
 581     return DWFL_E_LIBELF;
 582
 583   Dwfl_Error result = DWFL_E_NOERROR;
 584   bool first_badreltype = true;
 585
 586   size_t sh_entsize
 587     = gelf_fsize (relocated, shdr->sh_type == SHT_REL ? ELF_T_REL : ELF_T_RELA,
 588                   1, EV_CURRENT);
 589   size_t nrels = shdr->sh_size / sh_entsize;
 590   size_t complete = 0;
 591   if (shdr->sh_type == SHT_REL)
 592     for (size_t relidx = 0; !result && relidx < nrels; ++relidx)
 593       {
 594         GElf_Rel rel_mem, *r = gelf_getrel (reldata, relidx, &rel_mem);
 595         if (r == NULL)
 596           return DWFL_E_LIBELF;
 597         result = relocate (mod, relocated, reloc_symtab, tdata, ehdr,
 598                            r->r_offset, NULL,
 599                            GELF_R_TYPE (r->r_info),
 600                            GELF_R_SYM (r->r_info));
 601         check_badreltype (&first_badreltype, mod, &result);
 602         if (partial)
 603           switch (result)
 604             {
 605             case DWFL_E_NOERROR:
 606               /* We applied the relocation.  Elide it.  */
 607               memset (&rel_mem, 0, sizeof rel_mem);
 608               gelf_update_rel (reldata, relidx, &rel_mem);
 609               ++complete;
 610               break;
 611             case DWFL_E_BADRELTYPE:
 612             case DWFL_E_RELUNDEF:
 613               /* We couldn't handle this relocation.  Skip it.  */
 614               result = DWFL_E_NOERROR;
 615               break;
 616             default:
 617               break;
 618             }
 619       }
 620   else
 621     for (size_t relidx = 0; !result && relidx < nrels; ++relidx)
 622       {
 623         GElf_Rela rela_mem, *r = gelf_getrela (reldata, relidx,
 624                                                &rela_mem);
 625         if (r == NULL)
 626           return DWFL_E_LIBELF;
 627         result = relocate (mod, relocated, reloc_symtab, tdata, ehdr,
 628                            r->r_offset, &r->r_addend,
 629                            GELF_R_TYPE (r->r_info),
 630                            GELF_R_SYM (r->r_info));
 631         check_badreltype (&first_badreltype, mod, &result);
 632         if (partial)
 633           switch (result)
 634             {
 635             case DWFL_E_NOERROR:
 636               /* We applied the relocation.  Elide it.  */
 637               memset (&rela_mem, 0, sizeof rela_mem);
 638               gelf_update_rela (reldata, relidx, &rela_mem);
 639               ++complete;
 640               break;
 641             case DWFL_E_BADRELTYPE:
 642             case DWFL_E_RELUNDEF:
 643               /* We couldn't handle this relocation.  Skip it.  */
 644               result = DWFL_E_NOERROR;
 645               break;
 646             default:
 647               break;
 648             }
 649       }
 650
 651   if (likely (result == DWFL_E_NOERROR))
 652     {
 653       if (!partial || complete == nrels)
 654         /* Mark this relocation section as being empty now that we have
 655            done its work.  This affects unstrip -R, so e.g. it emits an
 656            empty .rela.debug_info along with a .debug_info that has
 657            already been fully relocated.  */
 658         nrels = 0;
 659       else if (complete != 0)
 660         {
 661           /* We handled some of the relocations but not all.
 662              We've zeroed out the ones we processed.
 663              Now remove them from the section.  */
 664
 665           size_t next = 0;
 666           if (shdr->sh_type == SHT_REL)
 667             for (size_t relidx = 0; relidx < nrels; ++relidx)
 668               {
 669                 GElf_Rel rel_mem;
 670                 GElf_Rel *r = gelf_getrel (reldata, relidx, &rel_mem);
 671                 if (r->r_info != 0 || r->r_offset != 0)
 672                   {
 673                     if (next != relidx)
 674                       gelf_update_rel (reldata, next, r);
 675                     ++next;
 676                   }
 677               }
 678           else
 679             for (size_t relidx = 0; relidx < nrels; ++relidx)
 680               {
 681                 GElf_Rela rela_mem;
 682                 GElf_Rela *r = gelf_getrela (reldata, relidx, &rela_mem);
 683                 if (r->r_info != 0 || r->r_offset != 0 || r->r_addend != 0)
 684                   {
 685                     if (next != relidx)
 686                       gelf_update_rela (reldata, next, r);
 687                     ++next;
 688                   }
 689               }
 690           nrels = next;
 691         }
 692
 693       shdr->sh_size = reldata->d_size = nrels * sh_entsize;
 694       gelf_update_shdr (scn, shdr);
 695     }
 696
 697   return result;
 698 }
 699
 700 Dwfl_Error
 701 internal_function
 702 __libdwfl_relocate (Dwfl_Module *mod, Elf *debugfile, bool debug)
 703 {
 704   assert (mod->e_type == ET_REL);
 705
 706   GElf_Ehdr ehdr_mem;
 707   const GElf_Ehdr *ehdr = gelf_getehdr (debugfile, &ehdr_mem);
 708   if (ehdr == NULL)
 709     return DWFL_E_LIBELF;
 710
 711   size_t d_shstrndx;
 712   if (elf_getshdrstrndx (debugfile, &d_shstrndx) < 0)
 713     return DWFL_E_LIBELF;
 714
 715   RELOC_SYMTAB_CACHE (reloc_symtab);
 716
 717   /* Look at each section in the debuginfo file, and process the
 718      relocation sections for debugging sections.  */
 719   Dwfl_Error result = DWFL_E_NOERROR;
 720   Elf_Scn *scn = NULL;
 721   while (result == DWFL_E_NOERROR
 722          && (scn = elf_nextscn (debugfile, scn)) != NULL)
 723     {
 724       GElf_Shdr shdr_mem;
 725       GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
 726
 727       if ((shdr->sh_type == SHT_REL || shdr->sh_type == SHT_RELA)
 728           && shdr->sh_size != 0)
 729         {
 730           /* It's a relocation section.  */
 731
 732           Elf_Scn *tscn = elf_getscn (debugfile, shdr->sh_info);
 733           if (unlikely (tscn == NULL))
 734             result = DWFL_E_LIBELF;
 735           else
 736             result = relocate_section (mod, debugfile, ehdr, d_shstrndx,
 737                                        &reloc_symtab, scn, shdr, tscn,
 738                                        debug, !debug);
 739         }
 740     }
 741
 742   return result;
 743 }
 744
 745 Dwfl_Error
 746 internal_function
 747 __libdwfl_relocate_section (Dwfl_Module *mod, Elf *relocated,
 748                             Elf_Scn *relocscn, Elf_Scn *tscn, bool partial)
 749 {
 750   GElf_Ehdr ehdr_mem;
 751   GElf_Shdr shdr_mem;
 752
 753   RELOC_SYMTAB_CACHE (reloc_symtab);
 754
 755   size_t shstrndx;
 756   if (elf_getshdrstrndx (relocated, &shstrndx) < 0)
 757     return DWFL_E_LIBELF;
 758
 759   return (__libdwfl_module_getebl (mod)
 760           ?: relocate_section (mod, relocated,
 761                                gelf_getehdr (relocated, &ehdr_mem), shstrndx,
 762                                &reloc_symtab,
 763                                relocscn, gelf_getshdr (relocscn, &shdr_mem),
 764                                tscn, false, partial));
 765 }