1 /* Create descriptor from ELF descriptor for processing file.
2 Copyright (C) 2002-2011, 2014, 2015, 2017, 2018 Red Hat, Inc.
3 This file is part of elfutils.
4
5 This file is free software; you can redistribute it and/or modify
6 it under the terms of either
7
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
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
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/>. */
28
29 #ifdef HAVE_CONFIG_H
30 # include <config.h>
31 #endif
32
33 #include <system.h>
34
35 #include <assert.h>
36 #include <stdbool.h>
37 #include <stddef.h>
38 #include <stdlib.h>
39 #include <stdio.h>
40 #include <string.h>
41 #include <sys/types.h>
42 #include <sys/stat.h>
43 #include <fcntl.h>
44
45 #include "libelfP.h"
46 #include "libdwP.h"
47
48
49 /* Section names. (Note .debug_str_offsets is the largest 19 chars.) */
50 static const char dwarf_scnnames[IDX_last][19] =
51 {
52 [IDX_debug_info] = ".debug_info",
53 [IDX_debug_types] = ".debug_types",
54 [IDX_debug_abbrev] = ".debug_abbrev",
55 [IDX_debug_addr] = ".debug_addr",
56 [IDX_debug_aranges] = ".debug_aranges",
57 [IDX_debug_line] = ".debug_line",
58 [IDX_debug_line_str] = ".debug_line_str",
59 [IDX_debug_frame] = ".debug_frame",
60 [IDX_debug_loc] = ".debug_loc",
61 [IDX_debug_loclists] = ".debug_loclists",
62 [IDX_debug_pubnames] = ".debug_pubnames",
63 [IDX_debug_str] = ".debug_str",
64 [IDX_debug_str_offsets] = ".debug_str_offsets",
65 [IDX_debug_macinfo] = ".debug_macinfo",
66 [IDX_debug_macro] = ".debug_macro",
67 [IDX_debug_ranges] = ".debug_ranges",
68 [IDX_debug_rnglists] = ".debug_rnglists",
69 [IDX_gnu_debugaltlink] = ".gnu_debugaltlink"
70 };
71 #define ndwarf_scnnames (sizeof (dwarf_scnnames) / sizeof (dwarf_scnnames[0]))
72
73 static enum dwarf_type
scn_dwarf_type(Dwarf * result,size_t shstrndx,Elf_Scn * scn)74 scn_dwarf_type (Dwarf *result, size_t shstrndx, Elf_Scn *scn)
75 {
76 GElf_Shdr shdr_mem;
77 GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
78 if (shdr == NULL)
79 return TYPE_UNKNOWN;
80
81 const char *scnname = elf_strptr (result->elf, shstrndx,
82 shdr->sh_name);
83 if (scnname != NULL)
84 {
85 if (startswith (scnname, ".gnu.debuglto_.debug"))
86 return TYPE_GNU_LTO;
87 else if (startswith (scnname, ".debug_") || startswith (scnname, ".zdebug_"))
88 {
89 size_t len = strlen (scnname);
90 if (strcmp (scnname + len - 4, ".dwo") == 0)
91 return TYPE_DWO;
92 else
93 return TYPE_PLAIN;
94 }
95 }
96 return TYPE_UNKNOWN;
97 }
98 static Dwarf *
check_section(Dwarf * result,size_t shstrndx,Elf_Scn * scn,bool inscngrp)99 check_section (Dwarf *result, size_t shstrndx, Elf_Scn *scn, bool inscngrp)
100 {
101 GElf_Shdr shdr_mem;
102 GElf_Shdr *shdr;
103
104 /* Get the section header data. */
105 shdr = gelf_getshdr (scn, &shdr_mem);
106 if (shdr == NULL)
107 /* We may read /proc/PID/mem with only program headers mapped and section
108 headers out of the mapped pages. */
109 goto err;
110
111 /* Ignore any SHT_NOBITS sections. Debugging sections should not
112 have been stripped, but in case of a corrupt file we won't try
113 to look at the missing data. */
114 if (unlikely (shdr->sh_type == SHT_NOBITS))
115 return result;
116
117 /* Make sure the section is part of a section group only iff we
118 really need it. If we are looking for the global (= non-section
119 group debug info) we have to ignore all the info in section
120 groups. If we are looking into a section group we cannot look at
121 a section which isn't part of the section group. */
122 if (! inscngrp && (shdr->sh_flags & SHF_GROUP) != 0)
123 /* Ignore the section. */
124 return result;
125
126
127 /* We recognize the DWARF section by their names. This is not very
128 safe and stable but the best we can do. */
129 const char *scnname = elf_strptr (result->elf, shstrndx,
130 shdr->sh_name);
131 if (scnname == NULL)
132 {
133 /* The section name must be valid. Otherwise is the ELF file
134 invalid. */
135 err:
136 Dwarf_Sig8_Hash_free (&result->sig8_hash);
137 __libdw_seterrno (DWARF_E_INVALID_ELF);
138 free (result);
139 return NULL;
140 }
141
142 /* Recognize the various sections. Most names start with .debug_.
143 They might be compressed (and start with .z). Or end with .dwo
144 for split dwarf sections. Or start with .gnu.debuglto_ for
145 LTO debug sections. We should only use one consistent set at
146 a time. We prefer PLAIN over DWO over LTO. */
147 size_t cnt;
148 bool gnu_compressed = false;
149 for (cnt = 0; cnt < ndwarf_scnnames; ++cnt)
150 {
151 size_t dbglen = strlen (dwarf_scnnames[cnt]);
152 size_t scnlen = strlen (scnname);
153 if (strncmp (scnname, dwarf_scnnames[cnt], dbglen) == 0
154 && (dbglen == scnlen
155 || (scnlen == dbglen + 4
156 && strstr (scnname, ".dwo") == scnname + dbglen)))
157 {
158 if (dbglen == scnlen)
159 {
160 if (result->type == TYPE_PLAIN)
161 break;
162 }
163 else if (result->type == TYPE_DWO)
164 break;
165 }
166 else if (scnname[0] == '.' && scnname[1] == 'z'
167 && (strncmp (&scnname[2], &dwarf_scnnames[cnt][1],
168 dbglen - 1) == 0
169 && (scnlen == dbglen + 1
170 || (scnlen == dbglen + 5
171 && strstr (scnname,
172 ".dwo") == scnname + dbglen + 1))))
173 {
174 if (scnlen == dbglen + 1)
175 {
176 if (result->type == TYPE_PLAIN)
177 {
178 gnu_compressed = true;
179 break;
180 }
181 }
182 else if (result->type <= TYPE_DWO)
183 {
184 gnu_compressed = true;
185 break;
186 }
187 }
188 else if (scnlen > 14 /* .gnu.debuglto_ prefix. */
189 && startswith (scnname, ".gnu.debuglto_")
190 && strcmp (&scnname[14], dwarf_scnnames[cnt]) == 0)
191 {
192 if (result->type == TYPE_GNU_LTO)
193 break;
194 }
195 }
196
197 if (cnt >= ndwarf_scnnames)
198 /* Not a debug section; ignore it. */
199 return result;
200
201 if (unlikely (result->sectiondata[cnt] != NULL))
202 /* A section appears twice. That's bad. We ignore the section. */
203 return result;
204
205 /* We cannot know whether or not a GNU compressed section has already
206 been uncompressed or not, so ignore any errors. */
207 if (gnu_compressed)
208 elf_compress_gnu (scn, 0, 0);
209
210 if ((shdr->sh_flags & SHF_COMPRESSED) != 0)
211 {
212 if (elf_compress (scn, 0, 0) < 0)
213 {
214 /* It would be nice if we could fail with a specific error.
215 But we don't know if this was an essential section or not.
216 So just continue for now. See also valid_p(). */
217 return result;
218 }
219 }
220
221 /* Get the section data. */
222 Elf_Data *data = elf_getdata (scn, NULL);
223 if (data == NULL)
224 goto err;
225
226 if (data->d_buf == NULL || data->d_size == 0)
227 /* No data actually available, ignore it. */
228 return result;
229
230 /* We can now read the section data into results. */
231 result->sectiondata[cnt] = data;
232
233 return result;
234 }
235
236
237 /* Helper function to set debugdir field. We want to cache the dir
238 where we found this Dwarf ELF file to locate alt and dwo files. */
239 char *
__libdw_debugdir(int fd)240 __libdw_debugdir (int fd)
241 {
242 /* strlen ("/proc/self/fd/") = 14 + strlen (<MAXINT>) = 10 + 1 = 25. */
243 char devfdpath[25];
244 sprintf (devfdpath, "/proc/self/fd/%u", fd);
245 char *fdpath = realpath (devfdpath, NULL);
246 char *fddir;
247 if (fdpath != NULL && fdpath[0] == '/'
248 && (fddir = strrchr (fdpath, '/')) != NULL)
249 {
250 *++fddir = '\0';
251 return fdpath;
252 }
253 return NULL;
254 }
255
256
257 /* Check whether all the necessary DWARF information is available. */
258 static Dwarf *
valid_p(Dwarf * result)259 valid_p (Dwarf *result)
260 {
261 /* We looked at all the sections. Now determine whether all the
262 sections with debugging information we need are there.
263
264 Require at least one section that can be read "standalone". */
265 if (likely (result != NULL)
266 && unlikely (result->sectiondata[IDX_debug_info] == NULL
267 && result->sectiondata[IDX_debug_line] == NULL
268 && result->sectiondata[IDX_debug_frame] == NULL))
269 {
270 Dwarf_Sig8_Hash_free (&result->sig8_hash);
271 __libdw_seterrno (DWARF_E_NO_DWARF);
272 free (result);
273 result = NULL;
274 }
275
276 /* We are setting up some "fake" CUs, which need an address size.
277 Check the ELF class to come up with something reasonable. */
278 int elf_addr_size = 8;
279 if (result != NULL)
280 {
281 GElf_Ehdr ehdr;
282 if (gelf_getehdr (result->elf, &ehdr) == NULL)
283 {
284 Dwarf_Sig8_Hash_free (&result->sig8_hash);
285 __libdw_seterrno (DWARF_E_INVALID_ELF);
286 free (result);
287 result = NULL;
288 }
289 else if (ehdr.e_ident[EI_CLASS] == ELFCLASS32)
290 elf_addr_size = 4;
291 }
292
293 /* For dwarf_location_attr () we need a "fake" CU to indicate
294 where the "fake" attribute data comes from. This is a block
295 inside the .debug_loc or .debug_loclists section. */
296 if (result != NULL && result->sectiondata[IDX_debug_loc] != NULL)
297 {
298 result->fake_loc_cu = malloc (sizeof (Dwarf_CU));
299 if (unlikely (result->fake_loc_cu == NULL))
300 {
301 Dwarf_Sig8_Hash_free (&result->sig8_hash);
302 __libdw_seterrno (DWARF_E_NOMEM);
303 free (result);
304 result = NULL;
305 }
306 else
307 {
308 result->fake_loc_cu->sec_idx = IDX_debug_loc;
309 result->fake_loc_cu->dbg = result;
310 result->fake_loc_cu->startp
311 = result->sectiondata[IDX_debug_loc]->d_buf;
312 result->fake_loc_cu->endp
313 = (result->sectiondata[IDX_debug_loc]->d_buf
314 + result->sectiondata[IDX_debug_loc]->d_size);
315 result->fake_loc_cu->locs = NULL;
316 result->fake_loc_cu->address_size = elf_addr_size;
317 result->fake_loc_cu->offset_size = 4;
318 result->fake_loc_cu->version = 4;
319 result->fake_loc_cu->split = NULL;
320 }
321 }
322
323 if (result != NULL && result->sectiondata[IDX_debug_loclists] != NULL)
324 {
325 result->fake_loclists_cu = malloc (sizeof (Dwarf_CU));
326 if (unlikely (result->fake_loclists_cu == NULL))
327 {
328 Dwarf_Sig8_Hash_free (&result->sig8_hash);
329 __libdw_seterrno (DWARF_E_NOMEM);
330 free (result->fake_loc_cu);
331 free (result);
332 result = NULL;
333 }
334 else
335 {
336 result->fake_loclists_cu->sec_idx = IDX_debug_loclists;
337 result->fake_loclists_cu->dbg = result;
338 result->fake_loclists_cu->startp
339 = result->sectiondata[IDX_debug_loclists]->d_buf;
340 result->fake_loclists_cu->endp
341 = (result->sectiondata[IDX_debug_loclists]->d_buf
342 + result->sectiondata[IDX_debug_loclists]->d_size);
343 result->fake_loclists_cu->locs = NULL;
344 result->fake_loclists_cu->address_size = elf_addr_size;
345 result->fake_loclists_cu->offset_size = 4;
346 result->fake_loclists_cu->version = 5;
347 result->fake_loclists_cu->split = NULL;
348 }
349 }
350
351 /* For DW_OP_constx/GNU_const_index and DW_OP_addrx/GNU_addr_index
352 the dwarf_location_attr () will need a "fake" address CU to
353 indicate where the attribute data comes from. This is a just
354 inside the .debug_addr section, if it exists. */
355 if (result != NULL && result->sectiondata[IDX_debug_addr] != NULL)
356 {
357 result->fake_addr_cu = malloc (sizeof (Dwarf_CU));
358 if (unlikely (result->fake_addr_cu == NULL))
359 {
360 Dwarf_Sig8_Hash_free (&result->sig8_hash);
361 __libdw_seterrno (DWARF_E_NOMEM);
362 free (result->fake_loc_cu);
363 free (result->fake_loclists_cu);
364 free (result);
365 result = NULL;
366 }
367 else
368 {
369 result->fake_addr_cu->sec_idx = IDX_debug_addr;
370 result->fake_addr_cu->dbg = result;
371 result->fake_addr_cu->startp
372 = result->sectiondata[IDX_debug_addr]->d_buf;
373 result->fake_addr_cu->endp
374 = (result->sectiondata[IDX_debug_addr]->d_buf
375 + result->sectiondata[IDX_debug_addr]->d_size);
376 result->fake_addr_cu->locs = NULL;
377 result->fake_addr_cu->address_size = elf_addr_size;
378 result->fake_addr_cu->offset_size = 4;
379 result->fake_addr_cu->version = 5;
380 result->fake_addr_cu->split = NULL;
381 }
382 }
383
384 if (result != NULL)
385 result->debugdir = __libdw_debugdir (result->elf->fildes);
386
387 return result;
388 }
389
390
391 static Dwarf *
global_read(Dwarf * result,Elf * elf,size_t shstrndx)392 global_read (Dwarf *result, Elf *elf, size_t shstrndx)
393 {
394 Elf_Scn *scn = NULL;
395
396 /* First check the type (PLAIN, DWO, LTO) we are looking for. We
397 prefer PLAIN if available over DWO, over LTO. */
398 while ((scn = elf_nextscn (elf, scn)) != NULL && result->type != TYPE_PLAIN)
399 {
400 enum dwarf_type type = scn_dwarf_type (result, shstrndx, scn);
401 if (type > result->type)
402 result->type = type;
403 }
404
405 scn = NULL;
406 while (result != NULL && (scn = elf_nextscn (elf, scn)) != NULL)
407 result = check_section (result, shstrndx, scn, false);
408
409 return valid_p (result);
410 }
411
412
413 static Dwarf *
scngrp_read(Dwarf * result,Elf * elf,size_t shstrndx,Elf_Scn * scngrp)414 scngrp_read (Dwarf *result, Elf *elf, size_t shstrndx, Elf_Scn *scngrp)
415 {
416 GElf_Shdr shdr_mem;
417 GElf_Shdr *shdr = gelf_getshdr (scngrp, &shdr_mem);
418 if (shdr == NULL)
419 {
420 Dwarf_Sig8_Hash_free (&result->sig8_hash);
421 __libdw_seterrno (DWARF_E_INVALID_ELF);
422 free (result);
423 return NULL;
424 }
425
426 if ((shdr->sh_flags & SHF_COMPRESSED) != 0
427 && elf_compress (scngrp, 0, 0) < 0)
428 {
429 Dwarf_Sig8_Hash_free (&result->sig8_hash);
430 __libdw_seterrno (DWARF_E_COMPRESSED_ERROR);
431 free (result);
432 return NULL;
433 }
434
435 /* SCNGRP is the section descriptor for a section group which might
436 contain debug sections. */
437 Elf_Data *data = elf_getdata (scngrp, NULL);
438 if (data == NULL)
439 {
440 /* We cannot read the section content. Fail! */
441 Dwarf_Sig8_Hash_free (&result->sig8_hash);
442 free (result);
443 return NULL;
444 }
445
446 /* The content of the section is a number of 32-bit words which
447 represent section indices. The first word is a flag word. */
448 Elf32_Word *scnidx = (Elf32_Word *) data->d_buf;
449 size_t cnt;
450
451 /* First check the type (PLAIN, DWO, LTO) we are looking for. We
452 prefer PLAIN if available over DWO, over LTO. */
453 for (cnt = 1; cnt * sizeof (Elf32_Word) <= data->d_size; ++cnt)
454 {
455 Elf_Scn *scn = elf_getscn (elf, scnidx[cnt]);
456 if (scn == NULL)
457 {
458 /* A section group refers to a non-existing section. Should
459 never happen. */
460 Dwarf_Sig8_Hash_free (&result->sig8_hash);
461 __libdw_seterrno (DWARF_E_INVALID_ELF);
462 free (result);
463 return NULL;
464 }
465
466 enum dwarf_type type = scn_dwarf_type (result, shstrndx, scn);
467 if (type > result->type)
468 result->type = type;
469 }
470
471 for (cnt = 1; cnt * sizeof (Elf32_Word) <= data->d_size && result != NULL; ++cnt)
472 {
473 Elf_Scn *scn = elf_getscn (elf, scnidx[cnt]);
474 assert (scn != NULL); // checked above
475 result = check_section (result, shstrndx, scn, true);
476 if (result == NULL)
477 break;
478 }
479
480 return valid_p (result);
481 }
482
483
484 Dwarf *
dwarf_begin_elf(Elf * elf,Dwarf_Cmd cmd,Elf_Scn * scngrp)485 dwarf_begin_elf (Elf *elf, Dwarf_Cmd cmd, Elf_Scn *scngrp)
486 {
487 GElf_Ehdr *ehdr;
488 GElf_Ehdr ehdr_mem;
489
490 /* Get the ELF header of the file. We need various pieces of
491 information from it. */
492 ehdr = gelf_getehdr (elf, &ehdr_mem);
493 if (ehdr == NULL)
494 {
495 if (elf_kind (elf) != ELF_K_ELF)
496 __libdw_seterrno (DWARF_E_NOELF);
497 else
498 __libdw_seterrno (DWARF_E_GETEHDR_ERROR);
499
500 return NULL;
501 }
502
503
504 /* Default memory allocation size. */
505 size_t mem_default_size = sysconf (_SC_PAGESIZE) - 4 * sizeof (void *);
506 assert (sizeof (struct Dwarf) < mem_default_size);
507
508 /* Allocate the data structure. */
509 Dwarf *result = calloc (1, sizeof (Dwarf));
510 if (unlikely (result == NULL)
511 || unlikely (Dwarf_Sig8_Hash_init (&result->sig8_hash, 11) < 0))
512 {
513 free (result);
514 __libdw_seterrno (DWARF_E_NOMEM);
515 return NULL;
516 }
517
518 /* Fill in some values. */
519 if ((BYTE_ORDER == LITTLE_ENDIAN && ehdr->e_ident[EI_DATA] == ELFDATA2MSB)
520 || (BYTE_ORDER == BIG_ENDIAN && ehdr->e_ident[EI_DATA] == ELFDATA2LSB))
521 result->other_byte_order = true;
522
523 result->elf = elf;
524 result->alt_fd = -1;
525
526 /* Initialize the memory handling. Initial blocks are allocated on first
527 actual allocation. */
528 result->mem_default_size = mem_default_size;
529 result->oom_handler = __libdw_oom;
530 if (pthread_rwlock_init(&result->mem_rwl, NULL) != 0)
531 {
532 free (result);
533 __libdw_seterrno (DWARF_E_NOMEM); /* no memory. */
534 return NULL;
535 }
536 result->mem_stacks = 0;
537 result->mem_tails = NULL;
538
539 if (cmd == DWARF_C_READ || cmd == DWARF_C_RDWR)
540 {
541 /* All sections are recognized by name, so pass the section header
542 string index along to easily get the section names. */
543 size_t shstrndx;
544 if (elf_getshdrstrndx (elf, &shstrndx) != 0)
545 {
546 Dwarf_Sig8_Hash_free (&result->sig8_hash);
547 __libdw_seterrno (DWARF_E_INVALID_ELF);
548 free (result);
549 return NULL;
550 }
551
552 /* If the caller provides a section group we get the DWARF
553 sections only from this section group. Otherwise we search
554 for the first section with the required name. Further
555 sections with the name are ignored. The DWARF specification
556 does not really say this is allowed. */
557 if (scngrp == NULL)
558 return global_read (result, elf, shstrndx);
559 else
560 return scngrp_read (result, elf, shstrndx, scngrp);
561 }
562 else if (cmd == DWARF_C_WRITE)
563 {
564 Dwarf_Sig8_Hash_free (&result->sig8_hash);
565 __libdw_seterrno (DWARF_E_UNIMPL);
566 free (result);
567 return NULL;
568 }
569
570 Dwarf_Sig8_Hash_free (&result->sig8_hash);
571 __libdw_seterrno (DWARF_E_INVALID_CMD);
572 free (result);
573 return NULL;
574 }
575 INTDEF(dwarf_begin_elf)
576