contrib/elftoolchain/libdwarf/libdwarf_reloc.c

   1 /*-
   2  * Copyright (c) 2010 Kai Wang
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include "_libdwarf.h"
  28
  29 ELFTC_VCSID("$Id: libdwarf_reloc.c 3578 2017-09-14 02:21:28Z emaste $");
  30
  31 Dwarf_Unsigned
  32 _dwarf_get_reloc_type(Dwarf_P_Debug dbg, int is64)
  33 {
  34
  35         assert(dbg != NULL);
  36
  37         switch (dbg->dbgp_isa) {
  38         case DW_ISA_AARCH64:
  39                 return (is64 ? R_AARCH64_ABS64 : R_AARCH64_ABS32);
  40         case DW_ISA_X86:
  41                 return (R_386_32);
  42         case DW_ISA_X86_64:
  43                 return (is64 ? R_X86_64_64 : R_X86_64_32);
  44         case DW_ISA_SPARC:
  45                 return (is64 ? R_SPARC_UA64 : R_SPARC_UA32);
  46         case DW_ISA_PPC:
  47                 return (is64 ? R_PPC64_ADDR64 : R_PPC_ADDR32);
  48         case DW_ISA_ARM:
  49                 return (R_ARM_ABS32);
  50         case DW_ISA_MIPS:
  51                 return (is64 ? R_MIPS_64 : R_MIPS_32);
  52         case DW_ISA_RISCV:
  53                 return (is64 ? R_RISCV_64 : R_RISCV_32);
  54         case DW_ISA_IA64:
  55                 return (is64 ? R_IA_64_DIR64LSB : R_IA_64_DIR32LSB);
  56         default:
  57                 break;
  58         }
  59         return (0);             /* NOT REACHED */
  60 }
  61
  62 int
  63 _dwarf_get_reloc_size(Dwarf_Debug dbg, Dwarf_Unsigned rel_type)
  64 {
  65
  66         switch (dbg->dbg_machine) {
  67         case EM_NONE:
  68                 break;
  69         case EM_AARCH64:
  70                 if (rel_type == R_AARCH64_ABS32)
  71                         return (4);
  72                 else if (rel_type == R_AARCH64_ABS64)
  73                         return (8);
  74                 break;
  75         case EM_ARM:
  76                 if (rel_type == R_ARM_ABS32)
  77                         return (4);
  78                 break;
  79         case EM_386:
  80         case EM_IAMCU:
  81                 if (rel_type == R_386_32)
  82                         return (4);
  83                 break;
  84         case EM_X86_64:
  85                 if (rel_type == R_X86_64_32)
  86                         return (4);
  87                 else if (rel_type == R_X86_64_64)
  88                         return (8);
  89                 break;
  90         case EM_SPARC:
  91                 if (rel_type == R_SPARC_UA32)
  92                         return (4);
  93                 else if (rel_type == R_SPARC_UA64)
  94                         return (8);
  95                 break;
  96         case EM_PPC:
  97                 if (rel_type == R_PPC_ADDR32)
  98                         return (4);
  99                 break;
 100         case EM_PPC64:
 101                 if (rel_type == R_PPC_ADDR32)
 102                         return (4);
 103                 else if (rel_type == R_PPC64_ADDR64)
 104                         return (8);
 105                 break;
 106         case EM_MIPS:
 107                 if (rel_type == R_MIPS_32)
 108                         return (4);
 109                 else if (rel_type == R_MIPS_64)
 110                         return (8);
 111                 break;
 112         case EM_RISCV:
 113                 if (rel_type == R_RISCV_32)
 114                         return (4);
 115                 else if (rel_type == R_RISCV_64)
 116                         return (8);
 117                 break;
 118         case EM_IA_64:
 119                 if (rel_type == R_IA_64_SECREL32LSB)
 120                         return (4);
 121                 else if (rel_type == R_IA_64_DIR64LSB)
 122                         return (8);
 123                 break;
 124         default:
 125                 break;
 126         }
 127
 128         /* unknown relocation. */
 129         return (0);
 130 }
 131
 132 int
 133 _dwarf_reloc_section_init(Dwarf_P_Debug dbg, Dwarf_Rel_Section *drsp,
 134     Dwarf_P_Section ref, Dwarf_Error *error)
 135 {
 136         Dwarf_Rel_Section drs;
 137         char name[128];
 138         int pseudo;
 139
 140         assert(dbg != NULL && drsp != NULL && ref != NULL);
 141
 142         if ((drs = calloc(1, sizeof(struct _Dwarf_Rel_Section))) == NULL) {
 143                 DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY);
 144                 return (DW_DLE_MEMORY);
 145         }
 146
 147         drs->drs_ref = ref;
 148
 149         /*
 150          * FIXME The logic here is most likely wrong. It should
 151          * be the ISA that determines relocation type.
 152          */
 153         if (dbg->dbgp_flags & DW_DLC_SIZE_64)
 154                 drs->drs_addend = 1;
 155         else
 156                 drs->drs_addend = 0;
 157
 158         if (dbg->dbgp_flags & DW_DLC_SYMBOLIC_RELOCATIONS)
 159                 pseudo = 1;
 160         else
 161                 pseudo = 0;
 162
 163         snprintf(name, sizeof(name), "%s%s",
 164             drs->drs_addend ? ".rela" : ".rel", ref->ds_name);
 165         if (_dwarf_section_init(dbg, &drs->drs_ds, name, pseudo, error) !=
 166             DW_DLE_NONE) {
 167                 free(drs);
 168                 DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY);
 169                 return (DW_DLE_MEMORY);
 170         }
 171
 172         STAILQ_INIT(&drs->drs_dre);
 173         STAILQ_INSERT_TAIL(&dbg->dbgp_drslist, drs, drs_next);
 174         dbg->dbgp_drscnt++;
 175         *drsp = drs;
 176
 177         return (DW_DLE_NONE);
 178 }
 179
 180 void
 181 _dwarf_reloc_section_free(Dwarf_P_Debug dbg, Dwarf_Rel_Section *drsp)
 182 {
 183         Dwarf_Rel_Section drs, tdrs;
 184         Dwarf_Rel_Entry dre, tdre;
 185
 186         assert(dbg != NULL && drsp != NULL);
 187
 188         if (*drsp == NULL)
 189                 return;
 190
 191         STAILQ_FOREACH_SAFE(drs, &dbg->dbgp_drslist, drs_next, tdrs) {
 192                 if (drs != *drsp)
 193                         continue;
 194                 STAILQ_REMOVE(&dbg->dbgp_drslist, drs, _Dwarf_Rel_Section,
 195                     drs_next);
 196                 STAILQ_FOREACH_SAFE(dre, &drs->drs_dre, dre_next, tdre) {
 197                         STAILQ_REMOVE(&drs->drs_dre, dre, _Dwarf_Rel_Entry,
 198                             dre_next);
 199                         free(dre);
 200                 }
 201                 if ((dbg->dbgp_flags & DW_DLC_SYMBOLIC_RELOCATIONS) == 0)
 202                         _dwarf_section_free(dbg, &drs->drs_ds);
 203                 else {
 204                         if (drs->drs_ds->ds_name)
 205                                 free(drs->drs_ds->ds_name);
 206                         free(drs->drs_ds);
 207                 }
 208                 free(drs);
 209                 *drsp = NULL;
 210                 dbg->dbgp_drscnt--;
 211                 break;
 212         }
 213 }
 214
 215 int
 216 _dwarf_reloc_entry_add(Dwarf_P_Debug dbg, Dwarf_Rel_Section drs,
 217     Dwarf_P_Section ds, unsigned char type, unsigned char length,
 218     Dwarf_Unsigned offset, Dwarf_Unsigned symndx, Dwarf_Unsigned addend,
 219     const char *secname, Dwarf_Error *error)
 220 {
 221         Dwarf_Rel_Entry dre;
 222         Dwarf_Unsigned reloff;
 223         int ret;
 224
 225         assert(drs != NULL);
 226         assert(offset <= ds->ds_size);
 227         reloff = offset;
 228
 229         /*
 230          * If the DW_DLC_SYMBOLIC_RELOCATIONS flag is set or ElfXX_Rel
 231          * is used instead of ELfXX_Rela, we need to write the addend
 232          * in the storage unit to be relocated. Otherwise write 0 in the
 233          * storage unit and the addend will be written into relocation
 234          * section later.
 235          */
 236         if ((dbg->dbgp_flags & DW_DLC_SYMBOLIC_RELOCATIONS) ||
 237             drs->drs_addend == 0)
 238                 ret = dbg->write_alloc(&ds->ds_data, &ds->ds_cap, &offset,
 239                     addend, length, error);
 240         else
 241                 ret = dbg->write_alloc(&ds->ds_data, &ds->ds_cap, &offset,
 242                     0, length, error);
 243         if (ret != DW_DLE_NONE)
 244                 return (ret);
 245         if (offset > ds->ds_size)
 246                 ds->ds_size = offset;
 247
 248         if ((dre = calloc(1, sizeof(struct _Dwarf_Rel_Entry))) == NULL) {
 249                 DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY);
 250                 return (DW_DLE_MEMORY);
 251         }
 252         STAILQ_INSERT_TAIL(&drs->drs_dre, dre, dre_next);
 253         dre->dre_type = type;
 254         dre->dre_length = length;
 255         dre->dre_offset = reloff;
 256         dre->dre_symndx = symndx;
 257         dre->dre_addend = addend;
 258         dre->dre_secname = secname;
 259         drs->drs_drecnt++;
 260
 261         return (DW_DLE_NONE);
 262 }
 263
 264 int
 265 _dwarf_reloc_entry_add_pair(Dwarf_P_Debug dbg, Dwarf_Rel_Section drs,
 266     Dwarf_P_Section ds, unsigned char length, Dwarf_Unsigned offset,
 267     Dwarf_Unsigned symndx, Dwarf_Unsigned esymndx, Dwarf_Unsigned symoff,
 268     Dwarf_Unsigned esymoff, Dwarf_Error *error)
 269 {
 270         Dwarf_Rel_Entry dre;
 271         Dwarf_Unsigned reloff;
 272         int ret;
 273
 274         assert(drs != NULL);
 275         assert(offset <= ds->ds_size);
 276         assert(dbg->dbgp_flags & DW_DLC_SYMBOLIC_RELOCATIONS);
 277         reloff = offset;
 278
 279         /* Write net offset into section stream. */
 280         ret = dbg->write_alloc(&ds->ds_data, &ds->ds_cap, &offset,
 281             esymoff - symoff, length, error);
 282         if (ret != DW_DLE_NONE)
 283                 return (ret);
 284         if (offset > ds->ds_size)
 285                 ds->ds_size = offset;
 286
 287         if ((dre = calloc(2, sizeof(struct _Dwarf_Rel_Entry))) == NULL) {
 288                 DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY);
 289                 return (DW_DLE_MEMORY);
 290         }
 291         STAILQ_INSERT_TAIL(&drs->drs_dre, &dre[0], dre_next);
 292         STAILQ_INSERT_TAIL(&drs->drs_dre, &dre[1], dre_next);
 293         dre[0].dre_type = dwarf_drt_first_of_length_pair;
 294         dre[0].dre_length = length;
 295         dre[0].dre_offset = reloff;
 296         dre[0].dre_symndx = symndx;
 297         dre[0].dre_addend = 0;
 298         dre[0].dre_secname = NULL;
 299         dre[1].dre_type = dwarf_drt_second_of_length_pair;
 300         dre[1].dre_length = length;
 301         dre[1].dre_offset = reloff;
 302         dre[1].dre_symndx = esymndx;
 303         dre[1].dre_addend = 0;
 304         dre[1].dre_secname = NULL;
 305         drs->drs_drecnt += 2;
 306
 307         return (DW_DLE_NONE);
 308 }
 309
 310 int
 311 _dwarf_reloc_section_finalize(Dwarf_P_Debug dbg, Dwarf_Rel_Section drs,
 312     Dwarf_Error *error)
 313 {
 314         Dwarf_P_Section ds;
 315         Dwarf_Unsigned unit;
 316         int ret, size;
 317
 318         assert(dbg != NULL && drs != NULL && drs->drs_ds != NULL &&
 319             drs->drs_ref != NULL);
 320
 321         ds = drs->drs_ds;
 322
 323         /*
 324          * Calculate the size (in bytes) of the relocation section.
 325          */
 326         if (dbg->dbgp_flags & DW_DLC_SIZE_64)
 327                 unit = drs->drs_addend ? sizeof(Elf64_Rela) : sizeof(Elf64_Rel);
 328         else
 329                 unit = drs->drs_addend ? sizeof(Elf32_Rela) : sizeof(Elf32_Rel);
 330         assert(ds->ds_size == 0);
 331         size = drs->drs_drecnt * unit;
 332
 333         /*
 334          * Discard this relocation section if there is no entry in it.
 335          */
 336         if (size == 0) {
 337                 _dwarf_reloc_section_free(dbg, &drs);
 338                 return (DW_DLE_NONE);
 339         }
 340
 341         /*
 342          * If we are under stream mode, realloc the section data block to
 343          * this size.
 344          */
 345         if ((dbg->dbgp_flags & DW_DLC_SYMBOLIC_RELOCATIONS) == 0) {
 346                 ds->ds_cap = size;
 347                 if ((ds->ds_data = realloc(ds->ds_data, (size_t) ds->ds_cap)) ==
 348                     NULL) {
 349                         DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY);
 350                         return (DW_DLE_MEMORY);
 351                 }
 352         }
 353
 354         /*
 355          * Notify the application the creation of this relocation section.
 356          * Note that the section link here should point to the .symtab
 357          * section, we set it to 0 since we have no way to know .symtab
 358          * section index.
 359          */
 360         ret = _dwarf_pro_callback(dbg, ds->ds_name, size,
 361             drs->drs_addend ? SHT_RELA : SHT_REL, 0, 0, drs->drs_ref->ds_ndx,
 362             &ds->ds_symndx, NULL);
 363         if (ret < 0) {
 364                 DWARF_SET_ERROR(dbg, error, DW_DLE_ELF_SECT_ERR);
 365                 return (DW_DLE_ELF_SECT_ERR);
 366         }
 367         ds->ds_ndx = ret;
 368
 369         return (DW_DLE_NONE);
 370 }
 371
 372 int
 373 _dwarf_reloc_section_gen(Dwarf_P_Debug dbg, Dwarf_Rel_Section drs,
 374     Dwarf_Error *error)
 375 {
 376         Dwarf_Rel_Entry dre;
 377         Dwarf_P_Section ds;
 378         Dwarf_Unsigned type;
 379         int ret;
 380
 381         assert((dbg->dbgp_flags & DW_DLC_SYMBOLIC_RELOCATIONS) == 0);
 382         assert(drs->drs_ds != NULL && drs->drs_ds->ds_size == 0);
 383         assert(!STAILQ_EMPTY(&drs->drs_dre));
 384         ds = drs->drs_ds;
 385
 386         STAILQ_FOREACH(dre, &drs->drs_dre, dre_next) {
 387                 assert(dre->dre_length == 4 || dre->dre_length == 8);
 388                 type = _dwarf_get_reloc_type(dbg, dre->dre_length == 8);
 389                 if (dbg->dbgp_flags & DW_DLC_SIZE_64) {
 390                         /* Write r_offset (8 bytes) */
 391                         ret = dbg->write_alloc(&ds->ds_data, &ds->ds_cap,
 392                             &ds->ds_size, dre->dre_offset, 8, error);
 393                         if (ret != DW_DLE_NONE)
 394                                 return (ret);
 395                         /* Write r_info (8 bytes) */
 396                         ret = dbg->write_alloc(&ds->ds_data, &ds->ds_cap,
 397                             &ds->ds_size, ELF64_R_INFO(dre->dre_symndx, type),
 398                             8, error);
 399                         if (ret != DW_DLE_NONE)
 400                                 return (ret);
 401                         /* Write r_addend (8 bytes) */
 402                         if (drs->drs_addend) {
 403                                 ret = dbg->write_alloc(&ds->ds_data,
 404                                     &ds->ds_cap, &ds->ds_size, dre->dre_addend,
 405                                     8, error);
 406                                 if (ret != DW_DLE_NONE)
 407                                         return (ret);
 408                         }
 409                 } else {
 410                         /* Write r_offset (4 bytes) */
 411                         ret = dbg->write_alloc(&ds->ds_data, &ds->ds_cap,
 412                             &ds->ds_size, dre->dre_offset, 4, error);
 413                         if (ret != DW_DLE_NONE)
 414                                 return (ret);
 415                         /* Write r_info (4 bytes) */
 416                         ret = dbg->write_alloc(&ds->ds_data, &ds->ds_cap,
 417                             &ds->ds_size, ELF32_R_INFO(dre->dre_symndx, type),
 418                             4, error);
 419                         if (ret != DW_DLE_NONE)
 420                                 return (ret);
 421                         /* Write r_addend (4 bytes) */
 422                         if (drs->drs_addend) {
 423                                 ret = dbg->write_alloc(&ds->ds_data,
 424                                     &ds->ds_cap, &ds->ds_size, dre->dre_addend,
 425                                     4, error);
 426                                 if (ret != DW_DLE_NONE)
 427                                         return (ret);
 428                         }
 429                 }
 430         }
 431         assert(ds->ds_size == ds->ds_cap);
 432
 433         return (DW_DLE_NONE);
 434 }
 435
 436 int
 437 _dwarf_reloc_gen(Dwarf_P_Debug dbg, Dwarf_Error *error)
 438 {
 439         Dwarf_Rel_Section drs;
 440         Dwarf_Rel_Entry dre;
 441         Dwarf_P_Section ds;
 442         int ret;
 443
 444         STAILQ_FOREACH(drs, &dbg->dbgp_drslist, drs_next) {
 445                 /*
 446                  * Update relocation entries: translate any section name
 447                  * reference to section symbol index.
 448                  */
 449                 STAILQ_FOREACH(dre, &drs->drs_dre, dre_next) {
 450                         if (dre->dre_secname == NULL)
 451                                 continue;
 452                         ds = _dwarf_pro_find_section(dbg, dre->dre_secname);
 453                         assert(ds != NULL && ds->ds_symndx != 0);
 454                         dre->dre_symndx = ds->ds_symndx;
 455                 }
 456
 457                 /*
 458                  * Generate ELF relocation section if we are under stream
 459                  * mode.
 460                  */
 461                 if ((dbg->dbgp_flags & DW_DLC_SYMBOLIC_RELOCATIONS) == 0) {
 462                         ret = _dwarf_reloc_section_gen(dbg, drs, error);
 463                         if (ret != DW_DLE_NONE)
 464                                 return (ret);
 465                 }
 466         }
 467
 468         return (DW_DLE_NONE);
 469 }
 470
 471 void
 472 _dwarf_reloc_cleanup(Dwarf_P_Debug dbg)
 473 {
 474         Dwarf_Rel_Section drs, tdrs;
 475         Dwarf_Rel_Entry dre, tdre;
 476
 477         assert(dbg != NULL && dbg->dbg_mode == DW_DLC_WRITE);
 478
 479         STAILQ_FOREACH_SAFE(drs, &dbg->dbgp_drslist, drs_next, tdrs) {
 480                 STAILQ_REMOVE(&dbg->dbgp_drslist, drs, _Dwarf_Rel_Section,
 481                     drs_next);
 482                 free(drs->drs_drd);
 483                 STAILQ_FOREACH_SAFE(dre, &drs->drs_dre, dre_next, tdre) {
 484                         STAILQ_REMOVE(&drs->drs_dre, dre, _Dwarf_Rel_Entry,
 485                             dre_next);
 486                         free(dre);
 487                 }
 488                 if (dbg->dbgp_flags & DW_DLC_SYMBOLIC_RELOCATIONS) {
 489                         if (drs->drs_ds) {
 490                                 if (drs->drs_ds->ds_name)
 491                                         free(drs->drs_ds->ds_name);
 492                                 free(drs->drs_ds);
 493                         }
 494                 }
 495                 free(drs);
 496         }
 497         dbg->dbgp_drscnt = 0;
 498         dbg->dbgp_drspos = NULL;
 499 }