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 2948 2013-05-30 21:25:52Z kaiwang27 $"); 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_X86: 39 return (R_386_32); 40 case DW_ISA_X86_64: 41 return (is64 ? R_X86_64_64 : R_X86_64_32); 42 case DW_ISA_SPARC: 43 return (is64 ? R_SPARC_UA64 : R_SPARC_UA32); 44 case DW_ISA_PPC: 45 return (R_PPC_ADDR32); 46 case DW_ISA_ARM: 47 return (R_ARM_ABS32); 48 case DW_ISA_MIPS: 49 return (is64 ? R_MIPS_64 : R_MIPS_32); 50 case DW_ISA_IA64: 51 return (is64 ? R_IA_64_DIR64LSB : R_IA_64_DIR32LSB); 52 default: 53 break; 54 } 55 return (0); /* NOT REACHED */ 56 } 57 58 int 59 _dwarf_get_reloc_size(Dwarf_Debug dbg, Dwarf_Unsigned rel_type) 60 { 61 62 switch (dbg->dbg_machine) { 63 case EM_NONE: 64 break; 65 case EM_ARM: 66 if (rel_type == R_ARM_ABS32) 67 return (4); 68 break; 69 case EM_386: 70 if (rel_type == R_386_32) 71 return (4); 72 break; 73 case EM_X86_64: 74 if (rel_type == R_X86_64_32) 75 return (4); 76 else if (rel_type == R_X86_64_64) 77 return (8); 78 break; 79 case EM_SPARC: 80 if (rel_type == R_SPARC_UA32) 81 return (4); 82 else if (rel_type == R_SPARC_UA64) 83 return (8); 84 break; 85 case EM_PPC: 86 if (rel_type == R_PPC_ADDR32) 87 return (4); 88 break; 89 case EM_MIPS: 90 if (rel_type == R_MIPS_32) 91 return (4); 92 else if (rel_type == R_MIPS_64) 93 return (8); 94 break; 95 case EM_IA_64: 96 if (rel_type == R_IA_64_SECREL32LSB) 97 return (4); 98 else if (rel_type == R_IA_64_DIR64LSB) 99 return (8); 100 break; 101 default: 102 break; 103 } 104 105 /* unknown relocation. */ 106 return (0); 107 } 108 109 int 110 _dwarf_reloc_section_init(Dwarf_P_Debug dbg, Dwarf_Rel_Section *drsp, 111 Dwarf_P_Section ref, Dwarf_Error *error) 112 { 113 Dwarf_Rel_Section drs; 114 char name[128]; 115 int pseudo; 116 117 assert(dbg != NULL && drsp != NULL && ref != NULL); 118 119 if ((drs = calloc(1, sizeof(struct _Dwarf_Rel_Section))) == NULL) { 120 DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY); 121 return (DW_DLE_MEMORY); 122 } 123 124 drs->drs_ref = ref; 125 126 /* 127 * FIXME The logic here is most likely wrong. It should 128 * be the ISA that determines relocation type. 129 */ 130 if (dbg->dbgp_flags & DW_DLC_SIZE_64) 131 drs->drs_addend = 1; 132 else 133 drs->drs_addend = 0; 134 135 if (dbg->dbgp_flags & DW_DLC_SYMBOLIC_RELOCATIONS) 136 pseudo = 1; 137 else 138 pseudo = 0; 139 140 snprintf(name, sizeof(name), "%s%s", 141 drs->drs_addend ? ".rela" : ".rel", ref->ds_name); 142 if (_dwarf_section_init(dbg, &drs->drs_ds, name, pseudo, error) != 143 DW_DLE_NONE) { 144 free(drs); 145 DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY); 146 return (DW_DLE_MEMORY); 147 } 148 149 STAILQ_INIT(&drs->drs_dre); 150 STAILQ_INSERT_TAIL(&dbg->dbgp_drslist, drs, drs_next); 151 dbg->dbgp_drscnt++; 152 *drsp = drs; 153 154 return (DW_DLE_NONE); 155 } 156 157 void 158 _dwarf_reloc_section_free(Dwarf_P_Debug dbg, Dwarf_Rel_Section *drsp) 159 { 160 Dwarf_Rel_Section drs, tdrs; 161 Dwarf_Rel_Entry dre, tdre; 162 163 assert(dbg != NULL && drsp != NULL); 164 165 if (*drsp == NULL) 166 return; 167 168 STAILQ_FOREACH_SAFE(drs, &dbg->dbgp_drslist, drs_next, tdrs) { 169 if (drs != *drsp) 170 continue; 171 STAILQ_REMOVE(&dbg->dbgp_drslist, drs, _Dwarf_Rel_Section, 172 drs_next); 173 STAILQ_FOREACH_SAFE(dre, &drs->drs_dre, dre_next, tdre) { 174 STAILQ_REMOVE(&drs->drs_dre, dre, _Dwarf_Rel_Entry, 175 dre_next); 176 free(dre); 177 } 178 if ((dbg->dbgp_flags & DW_DLC_SYMBOLIC_RELOCATIONS) == 0) 179 _dwarf_section_free(dbg, &drs->drs_ds); 180 else { 181 if (drs->drs_ds->ds_name) 182 free(drs->drs_ds->ds_name); 183 free(drs->drs_ds); 184 } 185 free(drs); 186 *drsp = NULL; 187 dbg->dbgp_drscnt--; 188 break; 189 } 190 } 191 192 int 193 _dwarf_reloc_entry_add(Dwarf_P_Debug dbg, Dwarf_Rel_Section drs, 194 Dwarf_P_Section ds, unsigned char type, unsigned char length, 195 Dwarf_Unsigned offset, Dwarf_Unsigned symndx, Dwarf_Unsigned addend, 196 const char *secname, Dwarf_Error *error) 197 { 198 Dwarf_Rel_Entry dre; 199 Dwarf_Unsigned reloff; 200 int ret; 201 202 assert(drs != NULL); 203 assert(offset <= ds->ds_size); 204 reloff = offset; 205 206 /* 207 * If the DW_DLC_SYMBOLIC_RELOCATIONS flag is set or ElfXX_Rel 208 * is used instead of ELfXX_Rela, we need to write the addend 209 * in the storage unit to be relocated. Otherwise write 0 in the 210 * storage unit and the addend will be written into relocation 211 * section later. 212 */ 213 if ((dbg->dbgp_flags & DW_DLC_SYMBOLIC_RELOCATIONS) || 214 drs->drs_addend == 0) 215 ret = dbg->write_alloc(&ds->ds_data, &ds->ds_cap, &offset, 216 addend, length, error); 217 else 218 ret = dbg->write_alloc(&ds->ds_data, &ds->ds_cap, &offset, 219 0, length, error); 220 if (ret != DW_DLE_NONE) 221 return (ret); 222 if (offset > ds->ds_size) 223 ds->ds_size = offset; 224 225 if ((dre = calloc(1, sizeof(struct _Dwarf_Rel_Entry))) == NULL) { 226 DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY); 227 return (DW_DLE_MEMORY); 228 } 229 STAILQ_INSERT_TAIL(&drs->drs_dre, dre, dre_next); 230 dre->dre_type = type; 231 dre->dre_length = length; 232 dre->dre_offset = reloff; 233 dre->dre_symndx = symndx; 234 dre->dre_addend = addend; 235 dre->dre_secname = secname; 236 drs->drs_drecnt++; 237 238 return (DW_DLE_NONE); 239 } 240 241 int 242 _dwarf_reloc_entry_add_pair(Dwarf_P_Debug dbg, Dwarf_Rel_Section drs, 243 Dwarf_P_Section ds, unsigned char length, Dwarf_Unsigned offset, 244 Dwarf_Unsigned symndx, Dwarf_Unsigned esymndx, Dwarf_Unsigned symoff, 245 Dwarf_Unsigned esymoff, Dwarf_Error *error) 246 { 247 Dwarf_Rel_Entry dre; 248 Dwarf_Unsigned reloff; 249 int ret; 250 251 assert(drs != NULL); 252 assert(offset <= ds->ds_size); 253 assert(dbg->dbgp_flags & DW_DLC_SYMBOLIC_RELOCATIONS); 254 reloff = offset; 255 256 /* Write net offset into section stream. */ 257 ret = dbg->write_alloc(&ds->ds_data, &ds->ds_cap, &offset, 258 esymoff - symoff, length, error); 259 if (ret != DW_DLE_NONE) 260 return (ret); 261 if (offset > ds->ds_size) 262 ds->ds_size = offset; 263 264 if ((dre = calloc(2, sizeof(struct _Dwarf_Rel_Entry))) == NULL) { 265 DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY); 266 return (DW_DLE_MEMORY); 267 } 268 STAILQ_INSERT_TAIL(&drs->drs_dre, &dre[0], dre_next); 269 STAILQ_INSERT_TAIL(&drs->drs_dre, &dre[1], dre_next); 270 dre[0].dre_type = dwarf_drt_first_of_length_pair; 271 dre[0].dre_length = length; 272 dre[0].dre_offset = reloff; 273 dre[0].dre_symndx = symndx; 274 dre[0].dre_addend = 0; 275 dre[0].dre_secname = NULL; 276 dre[1].dre_type = dwarf_drt_second_of_length_pair; 277 dre[1].dre_length = length; 278 dre[1].dre_offset = reloff; 279 dre[1].dre_symndx = esymndx; 280 dre[1].dre_addend = 0; 281 dre[1].dre_secname = NULL; 282 drs->drs_drecnt += 2; 283 284 return (DW_DLE_NONE); 285 } 286 287 int 288 _dwarf_reloc_section_finalize(Dwarf_P_Debug dbg, Dwarf_Rel_Section drs, 289 Dwarf_Error *error) 290 { 291 Dwarf_P_Section ds; 292 Dwarf_Unsigned unit; 293 int ret, size; 294 295 assert(dbg != NULL && drs != NULL && drs->drs_ds != NULL && 296 drs->drs_ref != NULL); 297 298 ds = drs->drs_ds; 299 300 /* 301 * Calculate the size (in bytes) of the relocation section. 302 */ 303 if (dbg->dbgp_flags & DW_DLC_SIZE_64) 304 unit = drs->drs_addend ? sizeof(Elf64_Rela) : sizeof(Elf64_Rel); 305 else 306 unit = drs->drs_addend ? sizeof(Elf32_Rela) : sizeof(Elf32_Rel); 307 assert(ds->ds_size == 0); 308 size = drs->drs_drecnt * unit; 309 310 /* 311 * Discard this relocation section if there is no entry in it. 312 */ 313 if (size == 0) { 314 _dwarf_reloc_section_free(dbg, &drs); 315 return (DW_DLE_NONE); 316 } 317 318 /* 319 * If we are under stream mode, realloc the section data block to 320 * this size. 321 */ 322 if ((dbg->dbgp_flags & DW_DLC_SYMBOLIC_RELOCATIONS) == 0) { 323 ds->ds_cap = size; 324 if ((ds->ds_data = realloc(ds->ds_data, (size_t) ds->ds_cap)) == 325 NULL) { 326 DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY); 327 return (DW_DLE_MEMORY); 328 } 329 } 330 331 /* 332 * Notify the application the creation of this relocation section. 333 * Note that the section link here should point to the .symtab 334 * section, we set it to 0 since we have no way to know .symtab 335 * section index. 336 */ 337 ret = _dwarf_pro_callback(dbg, ds->ds_name, size, 338 drs->drs_addend ? SHT_RELA : SHT_REL, 0, 0, drs->drs_ref->ds_ndx, 339 &ds->ds_symndx, NULL); 340 if (ret < 0) { 341 DWARF_SET_ERROR(dbg, error, DW_DLE_ELF_SECT_ERR); 342 return (DW_DLE_ELF_SECT_ERR); 343 } 344 ds->ds_ndx = ret; 345 346 return (DW_DLE_NONE); 347 } 348 349 int 350 _dwarf_reloc_section_gen(Dwarf_P_Debug dbg, Dwarf_Rel_Section drs, 351 Dwarf_Error *error) 352 { 353 Dwarf_Rel_Entry dre; 354 Dwarf_P_Section ds; 355 Dwarf_Unsigned type; 356 int ret; 357 358 assert((dbg->dbgp_flags & DW_DLC_SYMBOLIC_RELOCATIONS) == 0); 359 assert(drs->drs_ds != NULL && drs->drs_ds->ds_size == 0); 360 assert(!STAILQ_EMPTY(&drs->drs_dre)); 361 ds = drs->drs_ds; 362 363 STAILQ_FOREACH(dre, &drs->drs_dre, dre_next) { 364 assert(dre->dre_length == 4 || dre->dre_length == 8); 365 type = _dwarf_get_reloc_type(dbg, dre->dre_length == 8); 366 if (dbg->dbgp_flags & DW_DLC_SIZE_64) { 367 /* Write r_offset (8 bytes) */ 368 ret = dbg->write_alloc(&ds->ds_data, &ds->ds_cap, 369 &ds->ds_size, dre->dre_offset, 8, error); 370 if (ret != DW_DLE_NONE) 371 return (ret); 372 /* Write r_info (8 bytes) */ 373 ret = dbg->write_alloc(&ds->ds_data, &ds->ds_cap, 374 &ds->ds_size, ELF64_R_INFO(dre->dre_symndx, type), 375 8, error); 376 if (ret != DW_DLE_NONE) 377 return (ret); 378 /* Write r_addend (8 bytes) */ 379 if (drs->drs_addend) { 380 ret = dbg->write_alloc(&ds->ds_data, 381 &ds->ds_cap, &ds->ds_size, dre->dre_addend, 382 8, error); 383 if (ret != DW_DLE_NONE) 384 return (ret); 385 } 386 } else { 387 /* Write r_offset (4 bytes) */ 388 ret = dbg->write_alloc(&ds->ds_data, &ds->ds_cap, 389 &ds->ds_size, dre->dre_offset, 4, error); 390 if (ret != DW_DLE_NONE) 391 return (ret); 392 /* Write r_info (4 bytes) */ 393 ret = dbg->write_alloc(&ds->ds_data, &ds->ds_cap, 394 &ds->ds_size, ELF32_R_INFO(dre->dre_symndx, type), 395 4, error); 396 if (ret != DW_DLE_NONE) 397 return (ret); 398 /* Write r_addend (4 bytes) */ 399 if (drs->drs_addend) { 400 ret = dbg->write_alloc(&ds->ds_data, 401 &ds->ds_cap, &ds->ds_size, dre->dre_addend, 402 4, error); 403 if (ret != DW_DLE_NONE) 404 return (ret); 405 } 406 } 407 } 408 assert(ds->ds_size == ds->ds_cap); 409 410 return (DW_DLE_NONE); 411 } 412 413 int 414 _dwarf_reloc_gen(Dwarf_P_Debug dbg, Dwarf_Error *error) 415 { 416 Dwarf_Rel_Section drs; 417 Dwarf_Rel_Entry dre; 418 Dwarf_P_Section ds; 419 int ret; 420 421 STAILQ_FOREACH(drs, &dbg->dbgp_drslist, drs_next) { 422 /* 423 * Update relocation entries: translate any section name 424 * reference to section symbol index. 425 */ 426 STAILQ_FOREACH(dre, &drs->drs_dre, dre_next) { 427 if (dre->dre_secname == NULL) 428 continue; 429 ds = _dwarf_pro_find_section(dbg, dre->dre_secname); 430 assert(ds != NULL && ds->ds_symndx != 0); 431 dre->dre_symndx = ds->ds_symndx; 432 } 433 434 /* 435 * Generate ELF relocation section if we are under stream 436 * mode. 437 */ 438 if ((dbg->dbgp_flags & DW_DLC_SYMBOLIC_RELOCATIONS) == 0) { 439 ret = _dwarf_reloc_section_gen(dbg, drs, error); 440 if (ret != DW_DLE_NONE) 441 return (ret); 442 } 443 } 444 445 return (DW_DLE_NONE); 446 } 447 448 void 449 _dwarf_reloc_cleanup(Dwarf_P_Debug dbg) 450 { 451 Dwarf_Rel_Section drs, tdrs; 452 Dwarf_Rel_Entry dre, tdre; 453 454 assert(dbg != NULL && dbg->dbg_mode == DW_DLC_WRITE); 455 456 STAILQ_FOREACH_SAFE(drs, &dbg->dbgp_drslist, drs_next, tdrs) { 457 STAILQ_REMOVE(&dbg->dbgp_drslist, drs, _Dwarf_Rel_Section, 458 drs_next); 459 free(drs->drs_drd); 460 STAILQ_FOREACH_SAFE(dre, &drs->drs_dre, dre_next, tdre) { 461 STAILQ_REMOVE(&drs->drs_dre, dre, _Dwarf_Rel_Entry, 462 dre_next); 463 free(dre); 464 } 465 if (dbg->dbgp_flags & DW_DLC_SYMBOLIC_RELOCATIONS) { 466 if (drs->drs_ds) { 467 if (drs->drs_ds->ds_name) 468 free(drs->drs_ds->ds_name); 469 free(drs->drs_ds); 470 } 471 } 472 free(drs); 473 } 474 dbg->dbgp_drscnt = 0; 475 dbg->dbgp_drspos = NULL; 476 } 477