1 /* Recover relocatibility for addresses computed from debug information. 2 Copyright (C) 2005-2010 Red Hat, Inc. 3 This file is part of Red Hat elfutils. 4 5 Red Hat elfutils is free software; you can redistribute it and/or modify 6 it under the terms of the GNU General Public License as published by the 7 Free Software Foundation; version 2 of the License. 8 9 Red Hat elfutils is distributed in the hope that it will be useful, but 10 WITHOUT ANY WARRANTY; without even the implied warranty of 11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 General Public License for more details. 13 14 You should have received a copy of the GNU General Public License along 15 with Red Hat elfutils; if not, write to the Free Software Foundation, 16 Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA. 17 18 In addition, as a special exception, Red Hat, Inc. gives You the 19 additional right to link the code of Red Hat elfutils with code licensed 20 under any Open Source Initiative certified open source license 21 (http://www.opensource.org/licenses/index.php) which requires the 22 distribution of source code with any binary distribution and to 23 distribute linked combinations of the two. Non-GPL Code permitted under 24 this exception must only link to the code of Red Hat elfutils through 25 those well defined interfaces identified in the file named EXCEPTION 26 found in the source code files (the "Approved Interfaces"). The files 27 of Non-GPL Code may instantiate templates or use macros or inline 28 functions from the Approved Interfaces without causing the resulting 29 work to be covered by the GNU General Public License. Only Red Hat, 30 Inc. may make changes or additions to the list of Approved Interfaces. 31 Red Hat's grant of this exception is conditioned upon your not adding 32 any new exceptions. If you wish to add a new Approved Interface or 33 exception, please contact Red Hat. You must obey the GNU General Public 34 License in all respects for all of the Red Hat elfutils code and other 35 code used in conjunction with Red Hat elfutils except the Non-GPL Code 36 covered by this exception. If you modify this file, you may extend this 37 exception to your version of the file, but you are not obligated to do 38 so. If you do not wish to provide this exception without modification, 39 you must delete this exception statement from your version and license 40 this file solely under the GPL without exception. 41 42 Red Hat elfutils is an included package of the Open Invention Network. 43 An included package of the Open Invention Network is a package for which 44 Open Invention Network licensees cross-license their patents. No patent 45 license is granted, either expressly or impliedly, by designation as an 46 included package. Should you wish to participate in the Open Invention 47 Network licensing program, please visit www.openinventionnetwork.com 48 <http://www.openinventionnetwork.com>. */ 49 50 #include "libdwflP.h" 51 52 struct dwfl_relocation 53 { 54 size_t count; 55 struct 56 { 57 Elf_Scn *scn; 58 Elf_Scn *relocs; 59 const char *name; 60 GElf_Addr start, end; 61 } refs[0]; 62 }; 63 64 65 struct secref 66 { 67 struct secref *next; 68 Elf_Scn *scn; 69 Elf_Scn *relocs; 70 const char *name; 71 GElf_Addr start, end; 72 }; 73 74 static int 75 compare_secrefs (const void *a, const void *b) 76 { 77 struct secref *const *p1 = a; 78 struct secref *const *p2 = b; 79 80 /* No signed difference calculation is correct here, since the 81 terms are unsigned and could be more than INT64_MAX apart. */ 82 if ((*p1)->start < (*p2)->start) 83 return -1; 84 if ((*p1)->start > (*p2)->start) 85 return 1; 86 87 return 0; 88 } 89 90 static int 91 cache_sections (Dwfl_Module *mod) 92 { 93 if (likely (mod->reloc_info != NULL)) 94 return mod->reloc_info->count; 95 96 struct secref *refs = NULL; 97 size_t nrefs = 0; 98 99 size_t shstrndx; 100 if (unlikely (elf_getshdrstrndx (mod->main.elf, &shstrndx) < 0)) 101 { 102 elf_error: 103 __libdwfl_seterrno (DWFL_E_LIBELF); 104 return -1; 105 } 106 107 bool check_reloc_sections = false; 108 Elf_Scn *scn = NULL; 109 while ((scn = elf_nextscn (mod->main.elf, scn)) != NULL) 110 { 111 GElf_Shdr shdr_mem; 112 GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem); 113 if (shdr == NULL) 114 goto elf_error; 115 116 if ((shdr->sh_flags & SHF_ALLOC) && shdr->sh_addr == 0 117 && mod->e_type == ET_REL) 118 { 119 /* This section might not yet have been looked at. */ 120 if (__libdwfl_relocate_value (mod, mod->main.elf, &shstrndx, 121 elf_ndxscn (scn), 122 &shdr->sh_addr) != DWFL_E_NOERROR) 123 continue; 124 shdr = gelf_getshdr (scn, &shdr_mem); 125 if (unlikely (shdr == NULL)) 126 goto elf_error; 127 } 128 129 if (shdr->sh_flags & SHF_ALLOC) 130 { 131 const char *name = elf_strptr (mod->main.elf, shstrndx, 132 shdr->sh_name); 133 if (unlikely (name == NULL)) 134 goto elf_error; 135 136 struct secref *newref = alloca (sizeof *newref); 137 newref->scn = scn; 138 newref->relocs = NULL; 139 newref->name = name; 140 newref->start = dwfl_adjusted_address (mod, shdr->sh_addr); 141 newref->end = newref->start + shdr->sh_size; 142 newref->next = refs; 143 refs = newref; 144 ++nrefs; 145 } 146 147 if (mod->e_type == ET_REL 148 && shdr->sh_size != 0 149 && (shdr->sh_type == SHT_REL || shdr->sh_type == SHT_RELA) 150 && mod->dwfl->callbacks->section_address != NULL) 151 { 152 if (shdr->sh_info < elf_ndxscn (scn)) 153 { 154 /* We've already looked at the section these relocs apply to. */ 155 Elf_Scn *tscn = elf_getscn (mod->main.elf, shdr->sh_info); 156 if (likely (tscn != NULL)) 157 for (struct secref *sec = refs; sec != NULL; sec = sec->next) 158 if (sec->scn == tscn) 159 { 160 sec->relocs = scn; 161 break; 162 } 163 } 164 else 165 /* We'll have to do a second pass. */ 166 check_reloc_sections = true; 167 } 168 } 169 170 mod->reloc_info = malloc (offsetof (struct dwfl_relocation, refs[nrefs])); 171 if (mod->reloc_info == NULL) 172 { 173 __libdwfl_seterrno (DWFL_E_NOMEM); 174 return -1; 175 } 176 177 struct secref **sortrefs = alloca (nrefs * sizeof sortrefs[0]); 178 for (size_t i = nrefs; i-- > 0; refs = refs->next) 179 sortrefs[i] = refs; 180 assert (refs == NULL); 181 182 qsort (sortrefs, nrefs, sizeof sortrefs[0], &compare_secrefs); 183 184 mod->reloc_info->count = nrefs; 185 for (size_t i = 0; i < nrefs; ++i) 186 { 187 mod->reloc_info->refs[i].name = sortrefs[i]->name; 188 mod->reloc_info->refs[i].scn = sortrefs[i]->scn; 189 mod->reloc_info->refs[i].relocs = sortrefs[i]->relocs; 190 mod->reloc_info->refs[i].start = sortrefs[i]->start; 191 mod->reloc_info->refs[i].end = sortrefs[i]->end; 192 } 193 194 if (unlikely (check_reloc_sections)) 195 { 196 /* There was a reloc section that preceded its target section. 197 So we have to scan again now that we have cached all the 198 possible target sections we care about. */ 199 200 scn = NULL; 201 while ((scn = elf_nextscn (mod->main.elf, scn)) != NULL) 202 { 203 GElf_Shdr shdr_mem; 204 GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem); 205 if (shdr == NULL) 206 goto elf_error; 207 208 if (shdr->sh_size != 0 209 && (shdr->sh_type == SHT_REL || shdr->sh_type == SHT_RELA)) 210 { 211 Elf_Scn *tscn = elf_getscn (mod->main.elf, shdr->sh_info); 212 if (likely (tscn != NULL)) 213 for (size_t i = 0; i < nrefs; ++i) 214 if (mod->reloc_info->refs[i].scn == tscn) 215 { 216 mod->reloc_info->refs[i].relocs = scn; 217 break; 218 } 219 } 220 } 221 } 222 223 return nrefs; 224 } 225 226 227 int 228 dwfl_module_relocations (Dwfl_Module *mod) 229 { 230 if (mod == NULL) 231 return -1; 232 233 switch (mod->e_type) 234 { 235 case ET_REL: 236 return cache_sections (mod); 237 238 case ET_DYN: 239 return 1; 240 241 case ET_EXEC: 242 assert (mod->main.vaddr == mod->low_addr); 243 break; 244 } 245 246 return 0; 247 } 248 249 const char * 250 dwfl_module_relocation_info (Dwfl_Module *mod, unsigned int idx, 251 Elf32_Word *shndxp) 252 { 253 if (mod == NULL) 254 return NULL; 255 256 switch (mod->e_type) 257 { 258 case ET_REL: 259 break; 260 261 case ET_DYN: 262 if (idx != 0) 263 return NULL; 264 if (shndxp) 265 *shndxp = SHN_ABS; 266 return ""; 267 268 default: 269 return NULL; 270 } 271 272 if (cache_sections (mod) < 0) 273 return NULL; 274 275 struct dwfl_relocation *sections = mod->reloc_info; 276 277 if (idx >= sections->count) 278 return NULL; 279 280 if (shndxp) 281 *shndxp = elf_ndxscn (sections->refs[idx].scn); 282 283 return sections->refs[idx].name; 284 } 285 286 /* Check that MOD is valid and make sure its relocation has been done. */ 287 static bool 288 check_module (Dwfl_Module *mod) 289 { 290 if (INTUSE(dwfl_module_getsymtab) (mod) < 0) 291 { 292 Dwfl_Error error = dwfl_errno (); 293 if (error != DWFL_E_NO_SYMTAB) 294 { 295 __libdwfl_seterrno (error); 296 return true; 297 } 298 } 299 300 if (mod->dw == NULL) 301 { 302 Dwarf_Addr bias; 303 if (INTUSE(dwfl_module_getdwarf) (mod, &bias) == NULL) 304 { 305 Dwfl_Error error = dwfl_errno (); 306 if (error != DWFL_E_NO_DWARF) 307 { 308 __libdwfl_seterrno (error); 309 return true; 310 } 311 } 312 } 313 314 return false; 315 } 316 317 /* Find the index in MOD->reloc_info.refs containing *ADDR. */ 318 static int 319 find_section (Dwfl_Module *mod, Dwarf_Addr *addr) 320 { 321 if (cache_sections (mod) < 0) 322 return -1; 323 324 struct dwfl_relocation *sections = mod->reloc_info; 325 326 /* The sections are sorted by address, so we can use binary search. */ 327 size_t l = 0, u = sections->count; 328 while (l < u) 329 { 330 size_t idx = (l + u) / 2; 331 if (*addr < sections->refs[idx].start) 332 u = idx; 333 else if (*addr > sections->refs[idx].end) 334 l = idx + 1; 335 else 336 { 337 /* Consider the limit of a section to be inside it, unless it's 338 inside the next one. A section limit address can appear in 339 line records. */ 340 if (*addr == sections->refs[idx].end 341 && idx < sections->count 342 && *addr == sections->refs[idx + 1].start) 343 ++idx; 344 345 *addr -= sections->refs[idx].start; 346 return idx; 347 } 348 } 349 350 __libdwfl_seterrno (DWFL_E (LIBDW, DWARF_E_NO_MATCH)); 351 return -1; 352 } 353 354 int 355 dwfl_module_relocate_address (Dwfl_Module *mod, Dwarf_Addr *addr) 356 { 357 if (unlikely (check_module (mod))) 358 return -1; 359 360 switch (mod->e_type) 361 { 362 case ET_REL: 363 return find_section (mod, addr); 364 365 case ET_DYN: 366 /* All relative to first and only relocation base: module start. */ 367 *addr -= mod->low_addr; 368 break; 369 370 default: 371 /* Already absolute, dwfl_module_relocations returned zero. We 372 shouldn't really have been called, but it's a harmless no-op. */ 373 break; 374 } 375 376 return 0; 377 } 378 INTDEF (dwfl_module_relocate_address) 379 380 Elf_Scn * 381 dwfl_module_address_section (Dwfl_Module *mod, Dwarf_Addr *address, 382 Dwarf_Addr *bias) 383 { 384 if (check_module (mod)) 385 return NULL; 386 387 int idx = find_section (mod, address); 388 if (idx < 0) 389 return NULL; 390 391 if (mod->reloc_info->refs[idx].relocs != NULL) 392 { 393 assert (mod->e_type == ET_REL); 394 395 Elf_Scn *tscn = mod->reloc_info->refs[idx].scn; 396 Elf_Scn *relocscn = mod->reloc_info->refs[idx].relocs; 397 Dwfl_Error result = __libdwfl_relocate_section (mod, mod->main.elf, 398 relocscn, tscn, true); 399 if (likely (result == DWFL_E_NOERROR)) 400 mod->reloc_info->refs[idx].relocs = NULL; 401 else 402 { 403 __libdwfl_seterrno (result); 404 return NULL; 405 } 406 } 407 408 *bias = dwfl_adjusted_address (mod, 0); 409 return mod->reloc_info->refs[idx].scn; 410 } 411 INTDEF (dwfl_module_address_section) 412
