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
compare_secrefs(const void * a,const void * b)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
cache_sections(Dwfl_Module * mod)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
dwfl_module_relocations(Dwfl_Module * mod)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 *
dwfl_module_relocation_info(Dwfl_Module * mod,unsigned int idx,Elf32_Word * shndxp)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
check_module(Dwfl_Module * mod)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
find_section(Dwfl_Module * mod,Dwarf_Addr * addr)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
dwfl_module_relocate_address(Dwfl_Module * mod,Dwarf_Addr * addr)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 }
INTDEF(dwfl_module_relocate_address)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