1 /* Recover relocatibility for addresses computed from debug information.
2 Copyright (C) 2005-2009, 2012 Red Hat, Inc.
3 This file is part of elfutils.
5 This file is free software; you can redistribute it and/or modify
6 it under the terms of either
8 * the GNU Lesser General Public License as published by the Free
9 Software Foundation; either version 3 of the License, or (at
10 your option) any later version
14 * the GNU General Public License as published by the Free
15 Software Foundation; either version 2 of the License, or (at
16 your option) any later version
18 or both in parallel, as here.
20 elfutils is distributed in the hope that it will be useful, but
21 WITHOUT ANY WARRANTY; without even the implied warranty of
22 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23 General Public License for more details.
25 You should have received copies of the GNU General Public License and
26 the GNU Lesser General Public License along with this program. If
27 not, see <http://www.gnu.org/licenses/>. */
33 /* Since dwfl_report_elf lays out the sections already, this will only be
34 called when the section headers of the debuginfo file are being
35 consulted instead, or for the section placed at 0. With binutils
36 strip-to-debug, the symbol table is in the debuginfo file and relocation
39 dwfl_offline_section_address (Dwfl_Module *mod,
40 void **userdata __attribute__ ((unused)),
41 const char *modname __attribute__ ((unused)),
42 Dwarf_Addr base __attribute__ ((unused)),
43 const char *secname __attribute__ ((unused)),
45 const GElf_Shdr *shdr __attribute__ ((unused)),
48 assert (mod->e_type == ET_REL);
49 assert (shdr->sh_addr == 0);
50 assert (shdr->sh_flags & SHF_ALLOC);
52 if (mod->debug.elf == NULL)
53 /* We are only here because sh_addr is zero even though layout is complete.
54 The first section in the first file under -e is placed at 0. */
57 /* The section numbers might not match between the two files.
58 The best we can rely on is the order of SHF_ALLOC sections. */
60 Elf_Scn *ourscn = elf_getscn (mod->debug.elf, shndx);
62 uint_fast32_t skip_alloc = 0;
63 while ((scn = elf_nextscn (mod->debug.elf, scn)) != ourscn)
67 GElf_Shdr *sh = gelf_getshdr (scn, &shdr_mem);
68 if (unlikely (sh == NULL))
70 if (sh->sh_flags & SHF_ALLOC)
75 while ((scn = elf_nextscn (mod->main.elf, scn)) != NULL)
78 GElf_Shdr *main_shdr = gelf_getshdr (scn, &shdr_mem);
79 if (unlikely (main_shdr == NULL))
81 if ((main_shdr->sh_flags & SHF_ALLOC) && skip_alloc-- == 0)
83 assert (main_shdr->sh_flags == shdr->sh_flags);
84 *addr = main_shdr->sh_addr;
89 /* This should never happen. */
92 INTDEF (dwfl_offline_section_address)
94 /* Forward declarations. */
95 static Dwfl_Module *process_elf (Dwfl *dwfl, const char *name,
96 const char *file_name, int fd, Elf *elf);
97 static Dwfl_Module *process_archive (Dwfl *dwfl, const char *name,
98 const char *file_name, int fd, Elf *elf,
99 int (*predicate) (const char *module,
102 /* Report one module for an ELF file, or many for an archive.
103 Always consumes ELF and FD. */
105 process_file (Dwfl *dwfl, const char *name, const char *file_name, int fd,
106 Elf *elf, int (*predicate) (const char *module,
109 switch (elf_kind (elf))
113 __libdwfl_seterrno (elf == NULL ? DWFL_E_LIBELF : DWFL_E_BADELF);
117 return process_elf (dwfl, name, file_name, fd, elf);
120 return process_archive (dwfl, name, file_name, fd, elf, predicate);
124 /* Report the open ELF file as a module. Always consumes ELF and FD. */
126 process_elf (Dwfl *dwfl, const char *name, const char *file_name, int fd,
129 Dwfl_Module *mod = __libdwfl_report_elf (dwfl, name, file_name, fd, elf,
130 dwfl->offline_next_address, true,
134 /* If this is an ET_EXEC file with fixed addresses, the address range
135 it consumed may or may not intersect with the arbitrary range we
136 will use for relocatable modules. Make sure we always use a free
137 range for the offline allocations. If this module did use
138 offline_next_address, it may have rounded it up for the module's
139 alignment requirements. */
140 if ((dwfl->offline_next_address >= mod->low_addr
141 || mod->low_addr - dwfl->offline_next_address < OFFLINE_REDZONE)
142 && dwfl->offline_next_address < mod->high_addr + OFFLINE_REDZONE)
143 dwfl->offline_next_address = mod->high_addr + OFFLINE_REDZONE;
145 /* Don't keep the file descriptor around. */
146 if (mod->main.fd != -1 && elf_cntl (mod->main.elf, ELF_C_FDREAD) == 0)
148 close (mod->main.fd);
156 /* Always consumes MEMBER. Returns elf_next result on success.
157 For errors returns ELF_C_NULL with *MOD set to null. */
159 process_archive_member (Dwfl *dwfl, const char *name, const char *file_name,
160 int (*predicate) (const char *module, const char *file),
161 int fd, Elf *member, Dwfl_Module **mod)
163 const Elf_Arhdr *h = elf_getarhdr (member);
164 if (unlikely (h == NULL))
166 __libdwfl_seterrno (DWFL_E_LIBELF);
173 if (!strcmp (h->ar_name, "/") || !strcmp (h->ar_name, "//")
174 || !strcmp (h->ar_name, "/SYM64/"))
177 /* Skip this and go to the next. */
178 Elf_Cmd result = elf_next (member);
184 if (unlikely (asprintf (&member_name, "%s(%s)", file_name, h->ar_name) < 0))
187 __libdwfl_seterrno (DWFL_E_NOMEM);
193 char *module_name = NULL;
194 if (name == NULL || name[0] == '\0')
196 else if (unlikely (asprintf (&module_name, "%s:%s", name, h->ar_name) < 0))
204 if (predicate != NULL)
206 /* Let the predicate decide whether to use this one. */
207 int want = (*predicate) (name, member_name);
212 if (unlikely (want < 0))
214 __libdwfl_seterrno (DWFL_E_CB);
221 /* We let __libdwfl_report_elf cache the fd in mod->main.fd,
222 though it's the same fd for all the members.
223 On module teardown we will close it only on the last Elf reference. */
224 *mod = process_file (dwfl, name, member_name, fd, member, predicate);
228 if (*mod == NULL) /* process_file called elf_end. */
231 /* Advance the archive-reading offset for the next iteration. */
232 return elf_next (member);
235 /* Report each member of the archive as its own module. */
237 process_archive (Dwfl *dwfl, const char *name, const char *file_name, int fd,
239 int (*predicate) (const char *module, const char *file))
242 Dwfl_Module *mod = NULL;
243 Elf *member = elf_begin (fd, ELF_C_READ_MMAP_PRIVATE, archive);
244 if (unlikely (member == NULL)) /* Empty archive. */
246 __libdwfl_seterrno (DWFL_E_BADELF);
250 while (process_archive_member (dwfl, name, file_name, predicate,
251 fd, member, &mod) != ELF_C_NULL)
252 member = elf_begin (fd, ELF_C_READ_MMAP_PRIVATE, archive);
254 /* We can drop the archive Elf handle even if we're still using members
255 in live modules. When the last module's elf_end on a member returns
256 zero, that module will close FD. If no modules survived the predicate,
257 we are all done with the file right here. */
258 if (mod != NULL /* If no modules, caller will clean up. */
259 && elf_end (archive) == 0)
267 __libdwfl_report_offline (Dwfl *dwfl, const char *name,
268 const char *file_name, int fd, bool closefd,
269 int (*predicate) (const char *module,
273 Dwfl_Error error = __libdw_open_file (&fd, &elf, closefd, true);
274 if (error != DWFL_E_NOERROR)
276 __libdwfl_seterrno (error);
279 Dwfl_Module *mod = process_file (dwfl, name, file_name, fd, elf, predicate);
290 dwfl_report_offline (Dwfl *dwfl, const char *name,
291 const char *file_name, int fd)
296 bool closefd = false;
300 fd = open64 (file_name, O_RDONLY);
303 __libdwfl_seterrno (DWFL_E_ERRNO);
308 return __libdwfl_report_offline (dwfl, name, file_name, fd, closefd, NULL);
310 INTDEF (dwfl_report_offline)