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