Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 1 | /* Find debugging and symbol information for a module in libdwfl. |
Roland McGrath | 2c7d0dd | 2011-01-04 19:29:53 -0800 | [diff] [blame] | 2 | Copyright (C) 2005-2011 Red Hat, Inc. |
Mark Wielaard | de2ed97 | 2012-06-05 17:15:16 +0200 | [diff] [blame] | 3 | This file is part of elfutils. |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 4 | |
Mark Wielaard | de2ed97 | 2012-06-05 17:15:16 +0200 | [diff] [blame] | 5 | This file is free software; you can redistribute it and/or modify |
| 6 | it under the terms of either |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 7 | |
Mark Wielaard | de2ed97 | 2012-06-05 17:15:16 +0200 | [diff] [blame] | 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 |
| 11 | |
| 12 | or |
| 13 | |
| 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 |
| 17 | |
| 18 | or both in parallel, as here. |
| 19 | |
| 20 | elfutils is distributed in the hope that it will be useful, but |
Ulrich Drepper | 361df7d | 2006-04-04 21:38:57 +0000 | [diff] [blame] | 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. |
| 24 | |
Mark Wielaard | de2ed97 | 2012-06-05 17:15:16 +0200 | [diff] [blame] | 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/>. */ |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 28 | |
| 29 | #include "libdwflP.h" |
| 30 | #include <fcntl.h> |
| 31 | #include <string.h> |
Roland McGrath | d17fac7 | 2005-08-23 08:20:21 +0000 | [diff] [blame] | 32 | #include <unistd.h> |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 33 | #include "../libdw/libdwP.h" /* DWARF_E_* values are here. */ |
| 34 | |
| 35 | |
| 36 | /* Open libelf FILE->fd and compute the load base of ELF as loaded in MOD. |
Roland McGrath | 5ad466d | 2011-01-11 10:17:01 -0800 | [diff] [blame] | 37 | When we return success, FILE->elf and FILE->vaddr are set up. */ |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 38 | static inline Dwfl_Error |
| 39 | open_elf (Dwfl_Module *mod, struct dwfl_file *file) |
| 40 | { |
| 41 | if (file->elf == NULL) |
| 42 | { |
Roland McGrath | e07da4f | 2011-03-08 16:26:02 -0800 | [diff] [blame] | 43 | /* CBFAIL uses errno if it's set, so clear it first in case we don't |
| 44 | set it with an open failure below. */ |
| 45 | errno = 0; |
| 46 | |
Roland McGrath | 059c83e | 2008-02-21 06:19:39 +0000 | [diff] [blame] | 47 | /* If there was a pre-primed file name left that the callback left |
| 48 | behind, try to open that file name. */ |
| 49 | if (file->fd < 0 && file->name != NULL) |
| 50 | file->fd = TEMP_FAILURE_RETRY (open64 (file->name, O_RDONLY)); |
| 51 | |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 52 | if (file->fd < 0) |
| 53 | return CBFAIL; |
| 54 | |
Roland McGrath | bca4315 | 2009-01-05 23:59:32 -0800 | [diff] [blame] | 55 | Dwfl_Error error = __libdw_open_file (&file->fd, &file->elf, true, false); |
| 56 | if (error != DWFL_E_NOERROR) |
| 57 | return error; |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 58 | } |
Roland McGrath | bca4315 | 2009-01-05 23:59:32 -0800 | [diff] [blame] | 59 | else if (unlikely (elf_kind (file->elf) != ELF_K_ELF)) |
Roland McGrath | 122f388 | 2008-08-26 07:20:29 +0000 | [diff] [blame] | 60 | { |
Roland McGrath | ed431dd | 2010-05-06 00:52:51 -0700 | [diff] [blame] | 61 | elf_end (file->elf); |
| 62 | file->elf = NULL; |
Roland McGrath | 122f388 | 2008-08-26 07:20:29 +0000 | [diff] [blame] | 63 | close (file->fd); |
| 64 | file->fd = -1; |
| 65 | return DWFL_E_BADELF; |
| 66 | } |
| 67 | |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 68 | GElf_Ehdr ehdr_mem, *ehdr = gelf_getehdr (file->elf, &ehdr_mem); |
| 69 | if (ehdr == NULL) |
Ulrich Drepper | 6258e74 | 2007-03-13 06:22:40 +0000 | [diff] [blame] | 70 | { |
| 71 | elf_error: |
Roland McGrath | ed431dd | 2010-05-06 00:52:51 -0700 | [diff] [blame] | 72 | elf_end (file->elf); |
| 73 | file->elf = NULL; |
Ulrich Drepper | 6258e74 | 2007-03-13 06:22:40 +0000 | [diff] [blame] | 74 | close (file->fd); |
| 75 | file->fd = -1; |
Roland McGrath | 122f388 | 2008-08-26 07:20:29 +0000 | [diff] [blame] | 76 | return DWFL_E (LIBELF, elf_errno ()); |
Ulrich Drepper | 6258e74 | 2007-03-13 06:22:40 +0000 | [diff] [blame] | 77 | } |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 78 | |
Roland McGrath | 1743d7f | 2010-11-12 16:46:47 -0800 | [diff] [blame] | 79 | if (mod->e_type != ET_REL) |
Roland McGrath | f95760a | 2010-01-07 20:24:34 -0800 | [diff] [blame] | 80 | { |
Roland McGrath | 2c7d0dd | 2011-01-04 19:29:53 -0800 | [diff] [blame] | 81 | /* In any non-ET_REL file, we compute the "synchronization address". |
| 82 | |
| 83 | We start with the address at the end of the first PT_LOAD |
| 84 | segment. When prelink converts REL to RELA in an ET_DYN |
| 85 | file, it expands the space between the beginning of the |
| 86 | segment and the actual code/data addresses. Since that |
| 87 | change wasn't made in the debug file, the distance from |
| 88 | p_vaddr to an address of interest (in an st_value or DWARF |
| 89 | data) now differs between the main and debug files. The |
| 90 | distance from address_sync to an address of interest remains |
| 91 | consistent. |
| 92 | |
| 93 | If there are no section headers at all (full stripping), then |
| 94 | the end of the first segment is a valid synchronization address. |
| 95 | This cannot happen in a prelinked file, since prelink itself |
| 96 | relies on section headers for prelinking and for undoing it. |
| 97 | (If you do full stripping on a prelinked file, then you get what |
| 98 | you deserve--you can neither undo the prelinking, nor expect to |
| 99 | line it up with a debug file separated before prelinking.) |
| 100 | |
| 101 | However, when prelink processes an ET_EXEC file, it can do |
| 102 | something different. There it juggles the "special" sections |
| 103 | (SHT_DYNSYM et al) to make space for the additional prelink |
| 104 | special sections. Sometimes it will do this by moving a special |
Roland McGrath | 5ad466d | 2011-01-11 10:17:01 -0800 | [diff] [blame] | 105 | section like .dynstr after the real program sections in the first |
| 106 | PT_LOAD segment--i.e. to the end. That changes the end address of |
| 107 | the segment, so it no longer lines up correctly and is not a valid |
| 108 | synchronization address to use. Because of this, we need to apply |
| 109 | a different prelink-savvy means to discover the synchronization |
| 110 | address when there is a separate debug file and a prelinked main |
| 111 | file. That is done in find_debuginfo, below. */ |
Roland McGrath | 2c7d0dd | 2011-01-04 19:29:53 -0800 | [diff] [blame] | 112 | |
Roland McGrath | f95760a | 2010-01-07 20:24:34 -0800 | [diff] [blame] | 113 | size_t phnum; |
| 114 | if (unlikely (elf_getphdrnum (file->elf, &phnum) != 0)) |
| 115 | goto elf_error; |
| 116 | |
Roland McGrath | 1743d7f | 2010-11-12 16:46:47 -0800 | [diff] [blame] | 117 | file->vaddr = file->address_sync = 0; |
Roland McGrath | f95760a | 2010-01-07 20:24:34 -0800 | [diff] [blame] | 118 | for (size_t i = 0; i < phnum; ++i) |
| 119 | { |
| 120 | GElf_Phdr ph_mem; |
| 121 | GElf_Phdr *ph = gelf_getphdr (file->elf, i, &ph_mem); |
Roland McGrath | 1743d7f | 2010-11-12 16:46:47 -0800 | [diff] [blame] | 122 | if (unlikely (ph == NULL)) |
Roland McGrath | f95760a | 2010-01-07 20:24:34 -0800 | [diff] [blame] | 123 | goto elf_error; |
Roland McGrath | 5ad466d | 2011-01-11 10:17:01 -0800 | [diff] [blame] | 124 | if (ph->p_type == PT_LOAD) |
Roland McGrath | f95760a | 2010-01-07 20:24:34 -0800 | [diff] [blame] | 125 | { |
Roland McGrath | 5ad466d | 2011-01-11 10:17:01 -0800 | [diff] [blame] | 126 | file->vaddr = ph->p_vaddr & -ph->p_align; |
| 127 | file->address_sync = ph->p_vaddr + ph->p_memsz; |
Roland McGrath | f95760a | 2010-01-07 20:24:34 -0800 | [diff] [blame] | 128 | break; |
| 129 | } |
| 130 | } |
| 131 | } |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 132 | |
Ulrich Drepper | 6258e74 | 2007-03-13 06:22:40 +0000 | [diff] [blame] | 133 | mod->e_type = ehdr->e_type; |
| 134 | |
| 135 | /* Relocatable Linux kernels are ET_EXEC but act like ET_DYN. */ |
Roland McGrath | 1743d7f | 2010-11-12 16:46:47 -0800 | [diff] [blame] | 136 | if (mod->e_type == ET_EXEC && file->vaddr != mod->low_addr) |
Ulrich Drepper | 6258e74 | 2007-03-13 06:22:40 +0000 | [diff] [blame] | 137 | mod->e_type = ET_DYN; |
| 138 | |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 139 | return DWFL_E_NOERROR; |
| 140 | } |
| 141 | |
| 142 | /* Find the main ELF file for this module and open libelf on it. |
| 143 | When we return success, MOD->main.elf and MOD->main.bias are set up. */ |
Roland McGrath | a605a3c | 2009-04-19 18:27:01 -0700 | [diff] [blame] | 144 | void |
Roland McGrath | 1036157 | 2009-04-20 11:50:50 -0700 | [diff] [blame] | 145 | internal_function |
Roland McGrath | a605a3c | 2009-04-19 18:27:01 -0700 | [diff] [blame] | 146 | __libdwfl_getelf (Dwfl_Module *mod) |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 147 | { |
| 148 | if (mod->main.elf != NULL /* Already done. */ |
| 149 | || mod->elferr != DWFL_E_NOERROR) /* Cached failure. */ |
| 150 | return; |
| 151 | |
| 152 | mod->main.fd = (*mod->dwfl->callbacks->find_elf) (MODCB_ARGS (mod), |
| 153 | &mod->main.name, |
| 154 | &mod->main.elf); |
Roland McGrath | ed431dd | 2010-05-06 00:52:51 -0700 | [diff] [blame] | 155 | const bool fallback = mod->main.elf == NULL && mod->main.fd < 0; |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 156 | mod->elferr = open_elf (mod, &mod->main); |
Roland McGrath | ed431dd | 2010-05-06 00:52:51 -0700 | [diff] [blame] | 157 | if (mod->elferr != DWFL_E_NOERROR) |
| 158 | return; |
Roland McGrath | 59ea7f3 | 2007-10-04 08:50:09 +0000 | [diff] [blame] | 159 | |
Roland McGrath | ed431dd | 2010-05-06 00:52:51 -0700 | [diff] [blame] | 160 | if (!mod->main.valid) |
Roland McGrath | 59ea7f3 | 2007-10-04 08:50:09 +0000 | [diff] [blame] | 161 | { |
| 162 | /* Clear any explicitly reported build ID, just in case it was wrong. |
| 163 | We'll fetch it from the file when asked. */ |
Roland McGrath | bfc0170 | 2008-04-06 01:57:32 +0000 | [diff] [blame] | 164 | free (mod->build_id_bits); |
| 165 | mod->build_id_bits = NULL; |
Roland McGrath | 59ea7f3 | 2007-10-04 08:50:09 +0000 | [diff] [blame] | 166 | mod->build_id_len = 0; |
| 167 | } |
Roland McGrath | ed431dd | 2010-05-06 00:52:51 -0700 | [diff] [blame] | 168 | else if (fallback) |
| 169 | { |
| 170 | /* We have an authoritative build ID for this module, so |
| 171 | don't use a file by name that doesn't match that ID. */ |
| 172 | |
| 173 | assert (mod->build_id_len > 0); |
| 174 | |
| 175 | switch (__builtin_expect (__libdwfl_find_build_id (mod, false, |
| 176 | mod->main.elf), 2)) |
| 177 | { |
| 178 | case 2: |
| 179 | /* Build ID matches as it should. */ |
| 180 | return; |
| 181 | |
| 182 | case -1: /* ELF error. */ |
| 183 | mod->elferr = INTUSE(dwfl_errno) (); |
| 184 | break; |
| 185 | |
| 186 | case 0: /* File has no build ID note. */ |
| 187 | case 1: /* FIle has a build ID that does not match. */ |
| 188 | mod->elferr = DWFL_E_WRONG_ID_ELF; |
| 189 | break; |
| 190 | |
| 191 | default: |
| 192 | abort (); |
| 193 | } |
| 194 | |
| 195 | /* We get here when it was the right ELF file. Clear it out. */ |
| 196 | elf_end (mod->main.elf); |
| 197 | mod->main.elf = NULL; |
| 198 | if (mod->main.fd >= 0) |
| 199 | { |
| 200 | close (mod->main.fd); |
| 201 | mod->main.fd = -1; |
| 202 | } |
| 203 | } |
Roland McGrath | 1743d7f | 2010-11-12 16:46:47 -0800 | [diff] [blame] | 204 | |
| 205 | mod->main_bias = mod->e_type == ET_REL ? 0 : mod->low_addr - mod->main.vaddr; |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 206 | } |
| 207 | |
Ulrich Drepper | c07fbb3 | 2007-03-30 19:14:59 +0000 | [diff] [blame] | 208 | /* Search an ELF file for a ".gnu_debuglink" section. */ |
| 209 | static const char * |
| 210 | find_debuglink (Elf *elf, GElf_Word *crc) |
| 211 | { |
| 212 | size_t shstrndx; |
Ulrich Drepper | f189493 | 2009-06-13 15:55:42 -0700 | [diff] [blame] | 213 | if (elf_getshdrstrndx (elf, &shstrndx) < 0) |
Ulrich Drepper | c07fbb3 | 2007-03-30 19:14:59 +0000 | [diff] [blame] | 214 | return NULL; |
| 215 | |
| 216 | Elf_Scn *scn = NULL; |
| 217 | while ((scn = elf_nextscn (elf, scn)) != NULL) |
| 218 | { |
| 219 | GElf_Shdr shdr_mem; |
| 220 | GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem); |
| 221 | if (shdr == NULL) |
| 222 | return NULL; |
| 223 | |
| 224 | const char *name = elf_strptr (elf, shstrndx, shdr->sh_name); |
| 225 | if (name == NULL) |
| 226 | return NULL; |
| 227 | |
| 228 | if (!strcmp (name, ".gnu_debuglink")) |
| 229 | break; |
| 230 | } |
| 231 | |
| 232 | if (scn == NULL) |
| 233 | return NULL; |
| 234 | |
| 235 | /* Found the .gnu_debuglink section. Extract its contents. */ |
| 236 | Elf_Data *rawdata = elf_rawdata (scn, NULL); |
| 237 | if (rawdata == NULL) |
| 238 | return NULL; |
| 239 | |
| 240 | Elf_Data crcdata = |
| 241 | { |
| 242 | .d_type = ELF_T_WORD, |
| 243 | .d_buf = crc, |
| 244 | .d_size = sizeof *crc, |
| 245 | .d_version = EV_CURRENT, |
| 246 | }; |
| 247 | Elf_Data conv = |
| 248 | { |
| 249 | .d_type = ELF_T_WORD, |
| 250 | .d_buf = rawdata->d_buf + rawdata->d_size - sizeof *crc, |
| 251 | .d_size = sizeof *crc, |
| 252 | .d_version = EV_CURRENT, |
| 253 | }; |
| 254 | |
| 255 | GElf_Ehdr ehdr_mem; |
| 256 | GElf_Ehdr *ehdr = gelf_getehdr (elf, &ehdr_mem); |
| 257 | if (ehdr == NULL) |
| 258 | return NULL; |
| 259 | |
| 260 | Elf_Data *d = gelf_xlatetom (elf, &crcdata, &conv, ehdr->e_ident[EI_DATA]); |
| 261 | if (d == NULL) |
| 262 | return NULL; |
| 263 | assert (d == &crcdata); |
| 264 | |
| 265 | return rawdata->d_buf; |
| 266 | } |
| 267 | |
Roland McGrath | 5ad466d | 2011-01-11 10:17:01 -0800 | [diff] [blame] | 268 | /* If the main file might have been prelinked, then we need to |
| 269 | discover the correct synchronization address between the main and |
| 270 | debug files. Because of prelink's section juggling, we cannot rely |
| 271 | on the address_sync computed from PT_LOAD segments (see open_elf). |
| 272 | |
| 273 | We will attempt to discover a synchronization address based on the |
| 274 | section headers instead. But finding a section address that is |
| 275 | safe to use requires identifying which sections are SHT_PROGBITS. |
| 276 | We can do that in the main file, but in the debug file all the |
| 277 | allocated sections have been transformed into SHT_NOBITS so we have |
| 278 | lost the means to match them up correctly. |
| 279 | |
| 280 | The only method left to us is to decode the .gnu.prelink_undo |
| 281 | section in the prelinked main file. This shows what the sections |
| 282 | looked like before prelink juggled them--when they still had a |
| 283 | direct correspondence to the debug file. */ |
| 284 | static Dwfl_Error |
| 285 | find_prelink_address_sync (Dwfl_Module *mod) |
| 286 | { |
| 287 | /* The magic section is only identified by name. */ |
| 288 | size_t shstrndx; |
| 289 | if (elf_getshdrstrndx (mod->main.elf, &shstrndx) < 0) |
| 290 | return DWFL_E_LIBELF; |
| 291 | |
| 292 | Elf_Scn *scn = NULL; |
| 293 | while ((scn = elf_nextscn (mod->main.elf, scn)) != NULL) |
| 294 | { |
| 295 | GElf_Shdr shdr_mem; |
| 296 | GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem); |
| 297 | if (unlikely (shdr == NULL)) |
| 298 | return DWFL_E_LIBELF; |
| 299 | if (shdr->sh_type == SHT_PROGBITS |
| 300 | && !(shdr->sh_flags & SHF_ALLOC) |
| 301 | && shdr->sh_name != 0) |
| 302 | { |
| 303 | const char *secname = elf_strptr (mod->main.elf, shstrndx, |
| 304 | shdr->sh_name); |
| 305 | if (unlikely (secname == NULL)) |
| 306 | return DWFL_E_LIBELF; |
| 307 | if (!strcmp (secname, ".gnu.prelink_undo")) |
| 308 | break; |
| 309 | } |
| 310 | } |
| 311 | |
| 312 | if (scn == NULL) |
| 313 | /* There was no .gnu.prelink_undo section. */ |
| 314 | return DWFL_E_NOERROR; |
| 315 | |
| 316 | Elf_Data *undodata = elf_rawdata (scn, NULL); |
| 317 | if (unlikely (undodata == NULL)) |
| 318 | return DWFL_E_LIBELF; |
| 319 | |
| 320 | /* Decode the section. It consists of the original ehdr, phdrs, |
| 321 | and shdrs (but omits section 0). */ |
| 322 | |
| 323 | union |
| 324 | { |
| 325 | Elf32_Ehdr e32; |
| 326 | Elf64_Ehdr e64; |
| 327 | } ehdr; |
| 328 | Elf_Data dst = |
| 329 | { |
| 330 | .d_buf = &ehdr, |
| 331 | .d_size = sizeof ehdr, |
| 332 | .d_type = ELF_T_EHDR, |
| 333 | .d_version = EV_CURRENT |
| 334 | }; |
| 335 | Elf_Data src = *undodata; |
| 336 | src.d_size = gelf_fsize (mod->main.elf, ELF_T_EHDR, 1, EV_CURRENT); |
| 337 | src.d_type = ELF_T_EHDR; |
| 338 | if (unlikely (gelf_xlatetom (mod->main.elf, &dst, &src, |
| 339 | elf_getident (mod->main.elf, NULL)[EI_DATA]) |
| 340 | == NULL)) |
| 341 | return DWFL_E_LIBELF; |
| 342 | |
| 343 | size_t shentsize = gelf_fsize (mod->main.elf, ELF_T_SHDR, 1, EV_CURRENT); |
| 344 | size_t phentsize = gelf_fsize (mod->main.elf, ELF_T_PHDR, 1, EV_CURRENT); |
| 345 | |
| 346 | uint_fast16_t phnum; |
| 347 | uint_fast16_t shnum; |
| 348 | if (ehdr.e32.e_ident[EI_CLASS] == ELFCLASS32) |
| 349 | { |
| 350 | if (ehdr.e32.e_shentsize != shentsize |
| 351 | || ehdr.e32.e_phentsize != phentsize) |
| 352 | return DWFL_E_BAD_PRELINK; |
| 353 | phnum = ehdr.e32.e_phnum; |
| 354 | shnum = ehdr.e32.e_shnum; |
| 355 | } |
| 356 | else |
| 357 | { |
| 358 | if (ehdr.e64.e_shentsize != shentsize |
| 359 | || ehdr.e64.e_phentsize != phentsize) |
| 360 | return DWFL_E_BAD_PRELINK; |
| 361 | phnum = ehdr.e64.e_phnum; |
| 362 | shnum = ehdr.e64.e_shnum; |
| 363 | } |
| 364 | |
| 365 | /* Since prelink does not store the zeroth section header in the undo |
| 366 | section, it cannot support SHN_XINDEX encoding. */ |
| 367 | if (unlikely (shnum >= SHN_LORESERVE) |
| 368 | || unlikely (undodata->d_size != (src.d_size |
| 369 | + phnum * phentsize |
| 370 | + (shnum - 1) * shentsize))) |
| 371 | return DWFL_E_BAD_PRELINK; |
| 372 | |
| 373 | /* We look at the allocated SHT_PROGBITS (or SHT_NOBITS) sections. (Most |
| 374 | every file will have some SHT_PROGBITS sections, but it's possible to |
| 375 | have one with nothing but .bss, i.e. SHT_NOBITS.) The special sections |
| 376 | that can be moved around have different sh_type values--except for |
| 377 | .interp, the section that became the PT_INTERP segment. So we exclude |
| 378 | the SHT_PROGBITS section whose address matches the PT_INTERP p_vaddr. |
| 379 | For this reason, we must examine the phdrs first to find PT_INTERP. */ |
| 380 | |
Roland McGrath | 0ef4020 | 2011-02-01 16:58:32 -0800 | [diff] [blame] | 381 | GElf_Addr main_interp = 0; |
| 382 | { |
| 383 | size_t main_phnum; |
| 384 | if (unlikely (elf_getphdrnum (mod->main.elf, &main_phnum))) |
| 385 | return DWFL_E_LIBELF; |
| 386 | for (size_t i = 0; i < main_phnum; ++i) |
| 387 | { |
| 388 | GElf_Phdr phdr; |
| 389 | if (unlikely (gelf_getphdr (mod->main.elf, i, &phdr) == NULL)) |
| 390 | return DWFL_E_LIBELF; |
| 391 | if (phdr.p_type == PT_INTERP) |
| 392 | { |
| 393 | main_interp = phdr.p_vaddr; |
| 394 | break; |
| 395 | } |
| 396 | } |
| 397 | } |
| 398 | |
Roland McGrath | 5ad466d | 2011-01-11 10:17:01 -0800 | [diff] [blame] | 399 | src.d_buf += src.d_size; |
| 400 | src.d_type = ELF_T_PHDR; |
| 401 | src.d_size = phnum * phentsize; |
| 402 | |
Roland McGrath | 0ef4020 | 2011-02-01 16:58:32 -0800 | [diff] [blame] | 403 | GElf_Addr undo_interp = 0; |
Roland McGrath | 5ad466d | 2011-01-11 10:17:01 -0800 | [diff] [blame] | 404 | { |
| 405 | union |
| 406 | { |
| 407 | Elf32_Phdr p32[phnum]; |
| 408 | Elf64_Phdr p64[phnum]; |
| 409 | } phdr; |
| 410 | dst.d_buf = &phdr; |
| 411 | dst.d_size = sizeof phdr; |
| 412 | if (unlikely (gelf_xlatetom (mod->main.elf, &dst, &src, |
| 413 | ehdr.e32.e_ident[EI_DATA]) == NULL)) |
| 414 | return DWFL_E_LIBELF; |
| 415 | if (ehdr.e32.e_ident[EI_CLASS] == ELFCLASS32) |
| 416 | { |
| 417 | for (uint_fast16_t i = 0; i < phnum; ++i) |
| 418 | if (phdr.p32[i].p_type == PT_INTERP) |
| 419 | { |
Roland McGrath | 0ef4020 | 2011-02-01 16:58:32 -0800 | [diff] [blame] | 420 | undo_interp = phdr.p32[i].p_vaddr; |
Roland McGrath | 5ad466d | 2011-01-11 10:17:01 -0800 | [diff] [blame] | 421 | break; |
| 422 | } |
| 423 | } |
| 424 | else |
| 425 | { |
| 426 | for (uint_fast16_t i = 0; i < phnum; ++i) |
Roland McGrath | 9fdd461 | 2011-02-01 16:09:43 -0800 | [diff] [blame] | 427 | if (phdr.p64[i].p_type == PT_INTERP) |
Roland McGrath | 5ad466d | 2011-01-11 10:17:01 -0800 | [diff] [blame] | 428 | { |
Roland McGrath | 0ef4020 | 2011-02-01 16:58:32 -0800 | [diff] [blame] | 429 | undo_interp = phdr.p64[i].p_vaddr; |
Roland McGrath | 5ad466d | 2011-01-11 10:17:01 -0800 | [diff] [blame] | 430 | break; |
| 431 | } |
| 432 | } |
| 433 | } |
| 434 | |
Roland McGrath | 0ef4020 | 2011-02-01 16:58:32 -0800 | [diff] [blame] | 435 | if (unlikely ((main_interp == 0) != (undo_interp == 0))) |
| 436 | return DWFL_E_BAD_PRELINK; |
| 437 | |
Roland McGrath | 5ad466d | 2011-01-11 10:17:01 -0800 | [diff] [blame] | 438 | src.d_buf += src.d_size; |
| 439 | src.d_type = ELF_T_SHDR; |
| 440 | src.d_size = gelf_fsize (mod->main.elf, ELF_T_SHDR, shnum - 1, EV_CURRENT); |
| 441 | |
| 442 | union |
| 443 | { |
| 444 | Elf32_Shdr s32[shnum - 1]; |
| 445 | Elf64_Shdr s64[shnum - 1]; |
| 446 | } shdr; |
| 447 | dst.d_buf = &shdr; |
| 448 | dst.d_size = sizeof shdr; |
| 449 | if (unlikely (gelf_xlatetom (mod->main.elf, &dst, &src, |
| 450 | ehdr.e32.e_ident[EI_DATA]) == NULL)) |
| 451 | return DWFL_E_LIBELF; |
| 452 | |
| 453 | /* Now we can look at the original section headers of the main file |
| 454 | before it was prelinked. First we'll apply our method to the main |
| 455 | file sections as they are after prelinking, to calculate the |
| 456 | synchronization address of the main file. Then we'll apply that |
| 457 | same method to the saved section headers, to calculate the matching |
Roland McGrath | 3a44c9a | 2011-02-01 19:06:21 -0800 | [diff] [blame] | 458 | synchronization address of the debug file. |
| 459 | |
| 460 | The method is to consider SHF_ALLOC sections that are either |
| 461 | SHT_PROGBITS or SHT_NOBITS, excluding the section whose sh_addr |
| 462 | matches the PT_INTERP p_vaddr. The special sections that can be |
| 463 | moved by prelink have other types, except for .interp (which |
| 464 | becomes PT_INTERP). The "real" sections cannot move as such, but |
| 465 | .bss can be split into .dynbss and .bss, with the total memory |
| 466 | image remaining the same but being spread across the two sections. |
| 467 | So we consider the highest section end, which still matches up. */ |
Roland McGrath | 5ad466d | 2011-01-11 10:17:01 -0800 | [diff] [blame] | 468 | |
| 469 | GElf_Addr highest; |
| 470 | |
Roland McGrath | 0ef4020 | 2011-02-01 16:58:32 -0800 | [diff] [blame] | 471 | inline void consider_shdr (GElf_Addr interp, |
| 472 | GElf_Word sh_type, |
Roland McGrath | 5ad466d | 2011-01-11 10:17:01 -0800 | [diff] [blame] | 473 | GElf_Xword sh_flags, |
Roland McGrath | 3a44c9a | 2011-02-01 19:06:21 -0800 | [diff] [blame] | 474 | GElf_Addr sh_addr, |
| 475 | GElf_Xword sh_size) |
Roland McGrath | 5ad466d | 2011-01-11 10:17:01 -0800 | [diff] [blame] | 476 | { |
| 477 | if ((sh_flags & SHF_ALLOC) |
| 478 | && ((sh_type == SHT_PROGBITS && sh_addr != interp) |
| 479 | || sh_type == SHT_NOBITS)) |
| 480 | { |
Roland McGrath | 3a44c9a | 2011-02-01 19:06:21 -0800 | [diff] [blame] | 481 | const GElf_Addr sh_end = sh_addr + sh_size; |
| 482 | if (sh_end > highest) |
| 483 | highest = sh_end; |
Roland McGrath | 5ad466d | 2011-01-11 10:17:01 -0800 | [diff] [blame] | 484 | } |
| 485 | } |
| 486 | |
| 487 | highest = 0; |
| 488 | scn = NULL; |
| 489 | while ((scn = elf_nextscn (mod->main.elf, scn)) != NULL) |
| 490 | { |
| 491 | GElf_Shdr sh_mem; |
| 492 | GElf_Shdr *sh = gelf_getshdr (scn, &sh_mem); |
| 493 | if (unlikely (sh == NULL)) |
| 494 | return DWFL_E_LIBELF; |
Roland McGrath | 3a44c9a | 2011-02-01 19:06:21 -0800 | [diff] [blame] | 495 | consider_shdr (main_interp, sh->sh_type, sh->sh_flags, |
| 496 | sh->sh_addr, sh->sh_size); |
Roland McGrath | 5ad466d | 2011-01-11 10:17:01 -0800 | [diff] [blame] | 497 | } |
| 498 | if (highest > mod->main.vaddr) |
| 499 | { |
| 500 | mod->main.address_sync = highest; |
| 501 | |
| 502 | highest = 0; |
| 503 | if (ehdr.e32.e_ident[EI_CLASS] == ELFCLASS32) |
| 504 | for (size_t i = 0; i < shnum - 1; ++i) |
Roland McGrath | 3a44c9a | 2011-02-01 19:06:21 -0800 | [diff] [blame] | 505 | consider_shdr (undo_interp, shdr.s32[i].sh_type, shdr.s32[i].sh_flags, |
| 506 | shdr.s32[i].sh_addr, shdr.s32[i].sh_size); |
Roland McGrath | 5ad466d | 2011-01-11 10:17:01 -0800 | [diff] [blame] | 507 | else |
| 508 | for (size_t i = 0; i < shnum - 1; ++i) |
Roland McGrath | 3a44c9a | 2011-02-01 19:06:21 -0800 | [diff] [blame] | 509 | consider_shdr (undo_interp, shdr.s64[i].sh_type, shdr.s64[i].sh_flags, |
| 510 | shdr.s64[i].sh_addr, shdr.s64[i].sh_size); |
Roland McGrath | 5ad466d | 2011-01-11 10:17:01 -0800 | [diff] [blame] | 511 | |
| 512 | if (highest > mod->debug.vaddr) |
| 513 | mod->debug.address_sync = highest; |
| 514 | else |
| 515 | return DWFL_E_BAD_PRELINK; |
| 516 | } |
| 517 | |
| 518 | return DWFL_E_NOERROR; |
| 519 | } |
Ulrich Drepper | c07fbb3 | 2007-03-30 19:14:59 +0000 | [diff] [blame] | 520 | |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 521 | /* Find the separate debuginfo file for this module and open libelf on it. |
| 522 | When we return success, MOD->debug is set up. */ |
| 523 | static Dwfl_Error |
| 524 | find_debuginfo (Dwfl_Module *mod) |
| 525 | { |
Roland McGrath | d17fac7 | 2005-08-23 08:20:21 +0000 | [diff] [blame] | 526 | if (mod->debug.elf != NULL) |
| 527 | return DWFL_E_NOERROR; |
| 528 | |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 529 | GElf_Word debuglink_crc = 0; |
Ulrich Drepper | c07fbb3 | 2007-03-30 19:14:59 +0000 | [diff] [blame] | 530 | const char *debuglink_file = find_debuglink (mod->main.elf, &debuglink_crc); |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 531 | |
| 532 | mod->debug.fd = (*mod->dwfl->callbacks->find_debuginfo) (MODCB_ARGS (mod), |
| 533 | mod->main.name, |
| 534 | debuglink_file, |
| 535 | debuglink_crc, |
| 536 | &mod->debug.name); |
Roland McGrath | 5ad466d | 2011-01-11 10:17:01 -0800 | [diff] [blame] | 537 | Dwfl_Error result = open_elf (mod, &mod->debug); |
| 538 | if (result == DWFL_E_NOERROR && mod->debug.address_sync != 0) |
| 539 | result = find_prelink_address_sync (mod); |
| 540 | return result; |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 541 | } |
| 542 | |
| 543 | |
Ulrich Drepper | b597dfa | 2007-10-16 05:21:27 +0000 | [diff] [blame] | 544 | /* Try to find a symbol table in FILE. |
| 545 | Returns DWFL_E_NOERROR if a proper one is found. |
| 546 | Returns DWFL_E_NO_SYMTAB if not, but still sets results for SHT_DYNSYM. */ |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 547 | static Dwfl_Error |
| 548 | load_symtab (struct dwfl_file *file, struct dwfl_file **symfile, |
| 549 | Elf_Scn **symscn, Elf_Scn **xndxscn, |
Mark Wielaard | ef431cd | 2011-10-31 23:17:06 +0100 | [diff] [blame] | 550 | size_t *syments, int *first_global, GElf_Word *strshndx) |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 551 | { |
Roland McGrath | d11f9cb | 2008-03-26 20:51:59 +0000 | [diff] [blame] | 552 | bool symtab = false; |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 553 | Elf_Scn *scn = NULL; |
| 554 | while ((scn = elf_nextscn (file->elf, scn)) != NULL) |
| 555 | { |
| 556 | GElf_Shdr shdr_mem, *shdr = gelf_getshdr (scn, &shdr_mem); |
| 557 | if (shdr != NULL) |
| 558 | switch (shdr->sh_type) |
| 559 | { |
| 560 | case SHT_SYMTAB: |
Roland McGrath | d11f9cb | 2008-03-26 20:51:59 +0000 | [diff] [blame] | 561 | symtab = true; |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 562 | *symscn = scn; |
| 563 | *symfile = file; |
| 564 | *strshndx = shdr->sh_link; |
| 565 | *syments = shdr->sh_size / shdr->sh_entsize; |
Mark Wielaard | ef431cd | 2011-10-31 23:17:06 +0100 | [diff] [blame] | 566 | *first_global = shdr->sh_info; |
Ulrich Drepper | b597dfa | 2007-10-16 05:21:27 +0000 | [diff] [blame] | 567 | if (*xndxscn != NULL) |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 568 | return DWFL_E_NOERROR; |
| 569 | break; |
| 570 | |
| 571 | case SHT_DYNSYM: |
Roland McGrath | d11f9cb | 2008-03-26 20:51:59 +0000 | [diff] [blame] | 572 | if (symtab) |
| 573 | break; |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 574 | /* Use this if need be, but keep looking for SHT_SYMTAB. */ |
| 575 | *symscn = scn; |
| 576 | *symfile = file; |
| 577 | *strshndx = shdr->sh_link; |
| 578 | *syments = shdr->sh_size / shdr->sh_entsize; |
| 579 | break; |
| 580 | |
| 581 | case SHT_SYMTAB_SHNDX: |
| 582 | *xndxscn = scn; |
Roland McGrath | d11f9cb | 2008-03-26 20:51:59 +0000 | [diff] [blame] | 583 | if (symtab) |
Ulrich Drepper | b597dfa | 2007-10-16 05:21:27 +0000 | [diff] [blame] | 584 | return DWFL_E_NOERROR; |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 585 | break; |
| 586 | |
| 587 | default: |
| 588 | break; |
| 589 | } |
| 590 | } |
Ulrich Drepper | b597dfa | 2007-10-16 05:21:27 +0000 | [diff] [blame] | 591 | |
Roland McGrath | d11f9cb | 2008-03-26 20:51:59 +0000 | [diff] [blame] | 592 | if (symtab) |
Ulrich Drepper | b597dfa | 2007-10-16 05:21:27 +0000 | [diff] [blame] | 593 | /* We found one, though no SHT_SYMTAB_SHNDX to go with it. */ |
| 594 | return DWFL_E_NOERROR; |
| 595 | |
| 596 | /* We found no SHT_SYMTAB, so any SHT_SYMTAB_SHNDX was bogus. |
| 597 | We might have found an SHT_DYNSYM and set *SYMSCN et al though. */ |
| 598 | *xndxscn = NULL; |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 599 | return DWFL_E_NO_SYMTAB; |
| 600 | } |
| 601 | |
Roland McGrath | 59ea7f3 | 2007-10-04 08:50:09 +0000 | [diff] [blame] | 602 | |
| 603 | /* Translate addresses into file offsets. |
| 604 | OFFS[*] start out zero and remain zero if unresolved. */ |
| 605 | static void |
Roland McGrath | f95760a | 2010-01-07 20:24:34 -0800 | [diff] [blame] | 606 | find_offsets (Elf *elf, size_t phnum, size_t n, |
Roland McGrath | 59ea7f3 | 2007-10-04 08:50:09 +0000 | [diff] [blame] | 607 | GElf_Addr addrs[n], GElf_Off offs[n]) |
| 608 | { |
| 609 | size_t unsolved = n; |
Roland McGrath | f95760a | 2010-01-07 20:24:34 -0800 | [diff] [blame] | 610 | for (size_t i = 0; i < phnum; ++i) |
Roland McGrath | 59ea7f3 | 2007-10-04 08:50:09 +0000 | [diff] [blame] | 611 | { |
| 612 | GElf_Phdr phdr_mem; |
| 613 | GElf_Phdr *phdr = gelf_getphdr (elf, i, &phdr_mem); |
| 614 | if (phdr != NULL && phdr->p_type == PT_LOAD && phdr->p_memsz > 0) |
| 615 | for (size_t j = 0; j < n; ++j) |
| 616 | if (offs[j] == 0 |
| 617 | && addrs[j] >= phdr->p_vaddr |
| 618 | && addrs[j] - phdr->p_vaddr < phdr->p_filesz) |
| 619 | { |
| 620 | offs[j] = addrs[j] - phdr->p_vaddr + phdr->p_offset; |
| 621 | if (--unsolved == 0) |
| 622 | break; |
| 623 | } |
| 624 | } |
| 625 | } |
| 626 | |
| 627 | /* Try to find a dynamic symbol table via phdrs. */ |
| 628 | static void |
| 629 | find_dynsym (Dwfl_Module *mod) |
| 630 | { |
| 631 | GElf_Ehdr ehdr_mem; |
| 632 | GElf_Ehdr *ehdr = gelf_getehdr (mod->main.elf, &ehdr_mem); |
| 633 | |
Roland McGrath | f95760a | 2010-01-07 20:24:34 -0800 | [diff] [blame] | 634 | size_t phnum; |
| 635 | if (unlikely (elf_getphdrnum (mod->main.elf, &phnum) != 0)) |
| 636 | return; |
| 637 | |
| 638 | for (size_t i = 0; i < phnum; ++i) |
Roland McGrath | 59ea7f3 | 2007-10-04 08:50:09 +0000 | [diff] [blame] | 639 | { |
| 640 | GElf_Phdr phdr_mem; |
| 641 | GElf_Phdr *phdr = gelf_getphdr (mod->main.elf, i, &phdr_mem); |
| 642 | if (phdr == NULL) |
| 643 | break; |
| 644 | |
| 645 | if (phdr->p_type == PT_DYNAMIC) |
| 646 | { |
| 647 | /* Examine the dynamic section for the pointers we need. */ |
| 648 | |
| 649 | Elf_Data *data = elf_getdata_rawchunk (mod->main.elf, |
| 650 | phdr->p_offset, phdr->p_filesz, |
| 651 | ELF_T_DYN); |
| 652 | if (data == NULL) |
| 653 | continue; |
| 654 | |
| 655 | enum |
| 656 | { |
| 657 | i_symtab, |
| 658 | i_strtab, |
| 659 | i_hash, |
| 660 | i_gnu_hash, |
| 661 | i_max |
| 662 | }; |
| 663 | GElf_Addr addrs[i_max] = { 0, }; |
| 664 | GElf_Xword strsz = 0; |
| 665 | size_t n = data->d_size / gelf_fsize (mod->main.elf, |
| 666 | ELF_T_DYN, 1, EV_CURRENT); |
| 667 | for (size_t j = 0; j < n; ++j) |
| 668 | { |
| 669 | GElf_Dyn dyn_mem; |
| 670 | GElf_Dyn *dyn = gelf_getdyn (data, j, &dyn_mem); |
| 671 | if (dyn != NULL) |
| 672 | switch (dyn->d_tag) |
| 673 | { |
| 674 | case DT_SYMTAB: |
| 675 | addrs[i_symtab] = dyn->d_un.d_ptr; |
| 676 | continue; |
| 677 | |
| 678 | case DT_HASH: |
| 679 | addrs[i_hash] = dyn->d_un.d_ptr; |
| 680 | continue; |
| 681 | |
| 682 | case DT_GNU_HASH: |
| 683 | addrs[i_gnu_hash] = dyn->d_un.d_ptr; |
| 684 | continue; |
| 685 | |
| 686 | case DT_STRTAB: |
| 687 | addrs[i_strtab] = dyn->d_un.d_ptr; |
| 688 | continue; |
| 689 | |
| 690 | case DT_STRSZ: |
| 691 | strsz = dyn->d_un.d_val; |
| 692 | continue; |
| 693 | |
| 694 | default: |
| 695 | continue; |
| 696 | |
| 697 | case DT_NULL: |
| 698 | break; |
| 699 | } |
| 700 | break; |
| 701 | } |
| 702 | |
| 703 | /* Translate pointers into file offsets. */ |
| 704 | GElf_Off offs[i_max] = { 0, }; |
Roland McGrath | f95760a | 2010-01-07 20:24:34 -0800 | [diff] [blame] | 705 | find_offsets (mod->main.elf, phnum, i_max, addrs, offs); |
Roland McGrath | 59ea7f3 | 2007-10-04 08:50:09 +0000 | [diff] [blame] | 706 | |
| 707 | /* Figure out the size of the symbol table. */ |
| 708 | if (offs[i_hash] != 0) |
| 709 | { |
| 710 | /* In the original format, .hash says the size of .dynsym. */ |
| 711 | |
| 712 | size_t entsz = SH_ENTSIZE_HASH (ehdr); |
| 713 | data = elf_getdata_rawchunk (mod->main.elf, |
| 714 | offs[i_hash] + entsz, entsz, |
| 715 | entsz == 4 ? ELF_T_WORD |
| 716 | : ELF_T_XWORD); |
| 717 | if (data != NULL) |
| 718 | mod->syments = (entsz == 4 |
| 719 | ? *(const GElf_Word *) data->d_buf |
| 720 | : *(const GElf_Xword *) data->d_buf); |
| 721 | } |
| 722 | if (offs[i_gnu_hash] != 0 && mod->syments == 0) |
| 723 | { |
| 724 | /* In the new format, we can derive it with some work. */ |
| 725 | |
| 726 | const struct |
| 727 | { |
| 728 | Elf32_Word nbuckets; |
| 729 | Elf32_Word symndx; |
| 730 | Elf32_Word maskwords; |
| 731 | Elf32_Word shift2; |
| 732 | } *header; |
| 733 | |
| 734 | data = elf_getdata_rawchunk (mod->main.elf, offs[i_gnu_hash], |
| 735 | sizeof *header, ELF_T_WORD); |
| 736 | if (data != NULL) |
| 737 | { |
| 738 | header = data->d_buf; |
| 739 | Elf32_Word nbuckets = header->nbuckets; |
| 740 | Elf32_Word symndx = header->symndx; |
| 741 | GElf_Off buckets_at = (offs[i_gnu_hash] + sizeof *header |
| 742 | + (gelf_getclass (mod->main.elf) |
| 743 | * sizeof (Elf32_Word) |
| 744 | * header->maskwords)); |
| 745 | |
| 746 | data = elf_getdata_rawchunk (mod->main.elf, buckets_at, |
| 747 | nbuckets * sizeof (Elf32_Word), |
| 748 | ELF_T_WORD); |
| 749 | if (data != NULL && symndx < nbuckets) |
| 750 | { |
| 751 | const Elf32_Word *const buckets = data->d_buf; |
| 752 | Elf32_Word maxndx = symndx; |
| 753 | for (Elf32_Word bucket = 0; bucket < nbuckets; ++bucket) |
| 754 | if (buckets[bucket] > maxndx) |
| 755 | maxndx = buckets[bucket]; |
| 756 | |
| 757 | GElf_Off hasharr_at = (buckets_at |
| 758 | + nbuckets * sizeof (Elf32_Word)); |
| 759 | hasharr_at += (maxndx - symndx) * sizeof (Elf32_Word); |
| 760 | do |
| 761 | { |
| 762 | data = elf_getdata_rawchunk (mod->main.elf, |
| 763 | hasharr_at, |
| 764 | sizeof (Elf32_Word), |
| 765 | ELF_T_WORD); |
| 766 | if (data != NULL |
| 767 | && (*(const Elf32_Word *) data->d_buf & 1u)) |
| 768 | { |
| 769 | mod->syments = maxndx + 1; |
| 770 | break; |
| 771 | } |
| 772 | ++maxndx; |
| 773 | hasharr_at += sizeof (Elf32_Word); |
| 774 | } while (data != NULL); |
| 775 | } |
| 776 | } |
| 777 | } |
| 778 | if (offs[i_strtab] > offs[i_symtab] && mod->syments == 0) |
| 779 | mod->syments = ((offs[i_strtab] - offs[i_symtab]) |
| 780 | / gelf_fsize (mod->main.elf, |
| 781 | ELF_T_SYM, 1, EV_CURRENT)); |
| 782 | |
| 783 | if (mod->syments > 0) |
| 784 | { |
| 785 | mod->symdata = elf_getdata_rawchunk (mod->main.elf, |
| 786 | offs[i_symtab], |
| 787 | gelf_fsize (mod->main.elf, |
| 788 | ELF_T_SYM, |
| 789 | mod->syments, |
| 790 | EV_CURRENT), |
| 791 | ELF_T_SYM); |
| 792 | if (mod->symdata != NULL) |
| 793 | { |
| 794 | mod->symstrdata = elf_getdata_rawchunk (mod->main.elf, |
| 795 | offs[i_strtab], |
| 796 | strsz, |
| 797 | ELF_T_BYTE); |
| 798 | if (mod->symstrdata == NULL) |
| 799 | mod->symdata = NULL; |
| 800 | } |
| 801 | if (mod->symdata == NULL) |
| 802 | mod->symerr = DWFL_E (LIBELF, elf_errno ()); |
| 803 | else |
| 804 | { |
| 805 | mod->symfile = &mod->main; |
| 806 | mod->symerr = DWFL_E_NOERROR; |
| 807 | } |
| 808 | return; |
| 809 | } |
| 810 | } |
| 811 | } |
| 812 | } |
| 813 | |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 814 | /* Try to find a symbol table in either MOD->main.elf or MOD->debug.elf. */ |
| 815 | static void |
| 816 | find_symtab (Dwfl_Module *mod) |
| 817 | { |
| 818 | if (mod->symdata != NULL /* Already done. */ |
| 819 | || mod->symerr != DWFL_E_NOERROR) /* Cached previous failure. */ |
| 820 | return; |
| 821 | |
Roland McGrath | a605a3c | 2009-04-19 18:27:01 -0700 | [diff] [blame] | 822 | __libdwfl_getelf (mod); |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 823 | mod->symerr = mod->elferr; |
| 824 | if (mod->symerr != DWFL_E_NOERROR) |
| 825 | return; |
| 826 | |
Mark Wielaard | ef431cd | 2011-10-31 23:17:06 +0100 | [diff] [blame] | 827 | mod->first_global = -1; /* Unknown, unless explicitly set by load_symtab. */ |
| 828 | |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 829 | /* First see if the main ELF file has the debugging information. */ |
| 830 | Elf_Scn *symscn = NULL, *xndxscn = NULL; |
| 831 | GElf_Word strshndx; |
| 832 | mod->symerr = load_symtab (&mod->main, &mod->symfile, &symscn, |
Mark Wielaard | ef431cd | 2011-10-31 23:17:06 +0100 | [diff] [blame] | 833 | &xndxscn, &mod->syments, &mod->first_global, |
| 834 | &strshndx); |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 835 | switch (mod->symerr) |
| 836 | { |
| 837 | default: |
| 838 | return; |
| 839 | |
| 840 | case DWFL_E_NOERROR: |
| 841 | break; |
| 842 | |
| 843 | case DWFL_E_NO_SYMTAB: |
| 844 | /* Now we have to look for a separate debuginfo file. */ |
| 845 | mod->symerr = find_debuginfo (mod); |
| 846 | switch (mod->symerr) |
| 847 | { |
| 848 | default: |
| 849 | return; |
| 850 | |
| 851 | case DWFL_E_NOERROR: |
| 852 | mod->symerr = load_symtab (&mod->debug, &mod->symfile, &symscn, |
Mark Wielaard | ef431cd | 2011-10-31 23:17:06 +0100 | [diff] [blame] | 853 | &xndxscn, &mod->syments, |
| 854 | &mod->first_global, &strshndx); |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 855 | break; |
| 856 | |
| 857 | case DWFL_E_CB: /* The find_debuginfo hook failed. */ |
| 858 | mod->symerr = DWFL_E_NO_SYMTAB; |
| 859 | break; |
| 860 | } |
| 861 | |
| 862 | switch (mod->symerr) |
| 863 | { |
| 864 | default: |
| 865 | return; |
| 866 | |
| 867 | case DWFL_E_NOERROR: |
| 868 | break; |
| 869 | |
| 870 | case DWFL_E_NO_SYMTAB: |
Roland McGrath | 59ea7f3 | 2007-10-04 08:50:09 +0000 | [diff] [blame] | 871 | if (symscn != NULL) |
| 872 | { |
| 873 | /* We still have the dynamic symbol table. */ |
| 874 | mod->symerr = DWFL_E_NOERROR; |
| 875 | break; |
| 876 | } |
| 877 | |
| 878 | /* Last ditch, look for dynamic symbols without section headers. */ |
| 879 | find_dynsym (mod); |
| 880 | return; |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 881 | } |
| 882 | break; |
| 883 | } |
| 884 | |
| 885 | /* This does some sanity checks on the string table section. */ |
| 886 | if (elf_strptr (mod->symfile->elf, strshndx, 0) == NULL) |
| 887 | { |
| 888 | elferr: |
| 889 | mod->symerr = DWFL_E (LIBELF, elf_errno ()); |
| 890 | return; |
| 891 | } |
| 892 | |
Mark Wielaard | ef431cd | 2011-10-31 23:17:06 +0100 | [diff] [blame] | 893 | /* Cache the data; MOD->syments and MOD->first_global were set above. */ |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 894 | |
Roland McGrath | 3712b28 | 2005-08-23 05:58:42 +0000 | [diff] [blame] | 895 | mod->symstrdata = elf_getdata (elf_getscn (mod->symfile->elf, strshndx), |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 896 | NULL); |
| 897 | if (mod->symstrdata == NULL) |
| 898 | goto elferr; |
| 899 | |
| 900 | if (xndxscn == NULL) |
| 901 | mod->symxndxdata = NULL; |
| 902 | else |
| 903 | { |
Roland McGrath | 3712b28 | 2005-08-23 05:58:42 +0000 | [diff] [blame] | 904 | mod->symxndxdata = elf_getdata (xndxscn, NULL); |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 905 | if (mod->symxndxdata == NULL) |
| 906 | goto elferr; |
| 907 | } |
| 908 | |
Roland McGrath | 3712b28 | 2005-08-23 05:58:42 +0000 | [diff] [blame] | 909 | mod->symdata = elf_getdata (symscn, NULL); |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 910 | if (mod->symdata == NULL) |
| 911 | goto elferr; |
| 912 | } |
| 913 | |
| 914 | |
Roland McGrath | 994b489 | 2005-12-05 22:46:21 +0000 | [diff] [blame] | 915 | /* Try to open a libebl backend for MOD. */ |
| 916 | Dwfl_Error |
Ulrich Drepper | 077c65f | 2006-07-12 19:54:51 +0000 | [diff] [blame] | 917 | internal_function |
Roland McGrath | 994b489 | 2005-12-05 22:46:21 +0000 | [diff] [blame] | 918 | __libdwfl_module_getebl (Dwfl_Module *mod) |
| 919 | { |
| 920 | if (mod->ebl == NULL) |
| 921 | { |
Roland McGrath | a605a3c | 2009-04-19 18:27:01 -0700 | [diff] [blame] | 922 | __libdwfl_getelf (mod); |
Roland McGrath | 994b489 | 2005-12-05 22:46:21 +0000 | [diff] [blame] | 923 | if (mod->elferr != DWFL_E_NOERROR) |
| 924 | return mod->elferr; |
| 925 | |
| 926 | mod->ebl = ebl_openbackend (mod->main.elf); |
| 927 | if (mod->ebl == NULL) |
| 928 | return DWFL_E_LIBEBL; |
| 929 | } |
| 930 | return DWFL_E_NOERROR; |
| 931 | } |
| 932 | |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 933 | /* Try to start up libdw on DEBUGFILE. */ |
| 934 | static Dwfl_Error |
Roland McGrath | d17fac7 | 2005-08-23 08:20:21 +0000 | [diff] [blame] | 935 | load_dw (Dwfl_Module *mod, struct dwfl_file *debugfile) |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 936 | { |
Roland McGrath | 059c83e | 2008-02-21 06:19:39 +0000 | [diff] [blame] | 937 | if (mod->e_type == ET_REL && !debugfile->relocated) |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 938 | { |
| 939 | const Dwfl_Callbacks *const cb = mod->dwfl->callbacks; |
| 940 | |
| 941 | /* The debugging sections have to be relocated. */ |
| 942 | if (cb->section_address == NULL) |
| 943 | return DWFL_E_NOREL; |
| 944 | |
Roland McGrath | 994b489 | 2005-12-05 22:46:21 +0000 | [diff] [blame] | 945 | Dwfl_Error error = __libdwfl_module_getebl (mod); |
| 946 | if (error != DWFL_E_NOERROR) |
| 947 | return error; |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 948 | |
| 949 | find_symtab (mod); |
| 950 | Dwfl_Error result = mod->symerr; |
| 951 | if (result == DWFL_E_NOERROR) |
Roland McGrath | e4c22ea | 2007-10-23 13:07:39 +0000 | [diff] [blame] | 952 | result = __libdwfl_relocate (mod, debugfile->elf, true); |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 953 | if (result != DWFL_E_NOERROR) |
| 954 | return result; |
Roland McGrath | d17fac7 | 2005-08-23 08:20:21 +0000 | [diff] [blame] | 955 | |
| 956 | /* Don't keep the file descriptors around. */ |
| 957 | if (mod->main.fd != -1 && elf_cntl (mod->main.elf, ELF_C_FDREAD) == 0) |
| 958 | { |
| 959 | close (mod->main.fd); |
| 960 | mod->main.fd = -1; |
| 961 | } |
| 962 | if (debugfile->fd != -1 && elf_cntl (debugfile->elf, ELF_C_FDREAD) == 0) |
| 963 | { |
| 964 | close (debugfile->fd); |
| 965 | debugfile->fd = -1; |
| 966 | } |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 967 | } |
| 968 | |
Roland McGrath | d17fac7 | 2005-08-23 08:20:21 +0000 | [diff] [blame] | 969 | mod->dw = INTUSE(dwarf_begin_elf) (debugfile->elf, DWARF_C_READ, NULL); |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 970 | if (mod->dw == NULL) |
| 971 | { |
Roland McGrath | 4959bf8 | 2005-08-09 10:31:08 +0000 | [diff] [blame] | 972 | int err = INTUSE(dwarf_errno) (); |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 973 | return err == DWARF_E_NO_DWARF ? DWFL_E_NO_DWARF : DWFL_E (LIBDW, err); |
| 974 | } |
| 975 | |
| 976 | /* Until we have iterated through all CU's, we might do lazy lookups. */ |
| 977 | mod->lazycu = 1; |
| 978 | |
| 979 | return DWFL_E_NOERROR; |
| 980 | } |
| 981 | |
| 982 | /* Try to start up libdw on either the main file or the debuginfo file. */ |
| 983 | static void |
| 984 | find_dw (Dwfl_Module *mod) |
| 985 | { |
| 986 | if (mod->dw != NULL /* Already done. */ |
| 987 | || mod->dwerr != DWFL_E_NOERROR) /* Cached previous failure. */ |
| 988 | return; |
| 989 | |
Roland McGrath | a605a3c | 2009-04-19 18:27:01 -0700 | [diff] [blame] | 990 | __libdwfl_getelf (mod); |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 991 | mod->dwerr = mod->elferr; |
| 992 | if (mod->dwerr != DWFL_E_NOERROR) |
| 993 | return; |
| 994 | |
| 995 | /* First see if the main ELF file has the debugging information. */ |
Roland McGrath | d17fac7 | 2005-08-23 08:20:21 +0000 | [diff] [blame] | 996 | mod->dwerr = load_dw (mod, &mod->main); |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 997 | switch (mod->dwerr) |
| 998 | { |
| 999 | case DWFL_E_NOERROR: |
| 1000 | mod->debug.elf = mod->main.elf; |
Roland McGrath | 1743d7f | 2010-11-12 16:46:47 -0800 | [diff] [blame] | 1001 | mod->debug.address_sync = mod->main.address_sync; |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 1002 | return; |
| 1003 | |
| 1004 | case DWFL_E_NO_DWARF: |
| 1005 | break; |
| 1006 | |
| 1007 | default: |
| 1008 | goto canonicalize; |
| 1009 | } |
| 1010 | |
| 1011 | /* Now we have to look for a separate debuginfo file. */ |
| 1012 | mod->dwerr = find_debuginfo (mod); |
| 1013 | switch (mod->dwerr) |
| 1014 | { |
| 1015 | case DWFL_E_NOERROR: |
Roland McGrath | d17fac7 | 2005-08-23 08:20:21 +0000 | [diff] [blame] | 1016 | mod->dwerr = load_dw (mod, &mod->debug); |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 1017 | break; |
| 1018 | |
| 1019 | case DWFL_E_CB: /* The find_debuginfo hook failed. */ |
| 1020 | mod->dwerr = DWFL_E_NO_DWARF; |
| 1021 | return; |
| 1022 | |
| 1023 | default: |
| 1024 | break; |
| 1025 | } |
| 1026 | |
| 1027 | canonicalize: |
| 1028 | mod->dwerr = __libdwfl_canon_error (mod->dwerr); |
| 1029 | } |
| 1030 | |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 1031 | Dwarf * |
| 1032 | dwfl_module_getdwarf (Dwfl_Module *mod, Dwarf_Addr *bias) |
| 1033 | { |
| 1034 | if (mod == NULL) |
| 1035 | return NULL; |
| 1036 | |
| 1037 | find_dw (mod); |
| 1038 | if (mod->dwerr == DWFL_E_NOERROR) |
| 1039 | { |
Roland McGrath | e4c22ea | 2007-10-23 13:07:39 +0000 | [diff] [blame] | 1040 | /* If dwfl_module_getelf was used previously, then partial apply |
| 1041 | relocation to miscellaneous sections in the debug file too. */ |
| 1042 | if (mod->e_type == ET_REL |
| 1043 | && mod->main.relocated && ! mod->debug.relocated) |
| 1044 | { |
| 1045 | mod->debug.relocated = true; |
| 1046 | if (mod->debug.elf != mod->main.elf) |
| 1047 | (void) __libdwfl_relocate (mod, mod->debug.elf, false); |
| 1048 | } |
| 1049 | |
Roland McGrath | 1743d7f | 2010-11-12 16:46:47 -0800 | [diff] [blame] | 1050 | *bias = dwfl_adjusted_dwarf_addr (mod, 0); |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 1051 | return mod->dw; |
| 1052 | } |
| 1053 | |
| 1054 | __libdwfl_seterrno (mod->dwerr); |
| 1055 | return NULL; |
| 1056 | } |
| 1057 | INTDEF (dwfl_module_getdwarf) |
| 1058 | |
Ulrich Drepper | e1812e1 | 2006-07-12 07:46:03 +0000 | [diff] [blame] | 1059 | int |
| 1060 | dwfl_module_getsymtab (Dwfl_Module *mod) |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 1061 | { |
| 1062 | if (mod == NULL) |
Ulrich Drepper | e1812e1 | 2006-07-12 07:46:03 +0000 | [diff] [blame] | 1063 | return -1; |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 1064 | |
| 1065 | find_symtab (mod); |
Ulrich Drepper | e1812e1 | 2006-07-12 07:46:03 +0000 | [diff] [blame] | 1066 | if (mod->symerr == DWFL_E_NOERROR) |
| 1067 | return mod->syments; |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 1068 | |
Ulrich Drepper | e1812e1 | 2006-07-12 07:46:03 +0000 | [diff] [blame] | 1069 | __libdwfl_seterrno (mod->symerr); |
| 1070 | return -1; |
Ulrich Drepper | b08d5a8 | 2005-07-26 05:00:05 +0000 | [diff] [blame] | 1071 | } |
Ulrich Drepper | e1812e1 | 2006-07-12 07:46:03 +0000 | [diff] [blame] | 1072 | INTDEF (dwfl_module_getsymtab) |