GDB (xrefs)
/tmp/gdb-7.10/gdb/solib-svr4.c
Go to the documentation of this file.
1 /* Handle SVR4 shared libraries for GDB, the GNU Debugger.
2 
3  Copyright (C) 1990-2015 Free Software Foundation, Inc.
4 
5  This file is part of GDB.
6 
7  This program is free software; you can redistribute it and/or modify
8  it under the terms of the GNU General Public License as published by
9  the Free Software Foundation; either version 3 of the License, or
10  (at your option) any later version.
11 
12  This program is distributed in the hope that it will be useful,
13  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  GNU General Public License for more details.
16 
17  You should have received a copy of the GNU General Public License
18  along with this program. If not, see <http://www.gnu.org/licenses/>. */
19 
20 #include "defs.h"
21 
22 #include "elf/external.h"
23 #include "elf/common.h"
24 #include "elf/mips.h"
25 
26 #include "symtab.h"
27 #include "bfd.h"
28 #include "symfile.h"
29 #include "objfiles.h"
30 #include "gdbcore.h"
31 #include "target.h"
32 #include "inferior.h"
33 #include "infrun.h"
34 #include "regcache.h"
35 #include "gdbthread.h"
36 #include "observer.h"
37 
38 #include "solist.h"
39 #include "solib.h"
40 #include "solib-svr4.h"
41 
42 #include "bfd-target.h"
43 #include "elf-bfd.h"
44 #include "exec.h"
45 #include "auxv.h"
46 #include "gdb_bfd.h"
47 #include "probe.h"
48 
49 static struct link_map_offsets *svr4_fetch_link_map_offsets (void);
50 static int svr4_have_link_map_offsets (void);
51 static void svr4_relocate_main_executable (void);
52 static void svr4_free_library_list (void *p_list);
53 
54 /* Link map info to include in an allocated so_list entry. */
55 
56 struct lm_info
57  {
58  /* Amount by which addresses in the binary should be relocated to
59  match the inferior. The direct inferior value is L_ADDR_INFERIOR.
60  When prelinking is involved and the prelink base address changes,
61  we may need a different offset - the recomputed offset is in L_ADDR.
62  It is commonly the same value. It is cached as we want to warn about
63  the difference and compute it only once. L_ADDR is valid
64  iff L_ADDR_P. */
66  unsigned int l_addr_p : 1;
67 
68  /* The target location of lm. */
70 
71  /* Values read in from inferior's fields of the same name. */
73  };
74 
75 /* On SVR4 systems, a list of symbols in the dynamic linker where
76  GDB can try to place a breakpoint to monitor shared library
77  events.
78 
79  If none of these symbols are found, or other errors occur, then
80  SVR4 systems will fall back to using a symbol as the "startup
81  mapping complete" breakpoint address. */
82 
83 static const char * const solib_break_names[] =
84 {
85  "r_debug_state",
86  "_r_debug_state",
87  "_dl_debug_state",
88  "rtld_db_dlactivity",
89  "__dl_rtld_db_dlactivity",
90  "_rtld_debug_state",
91 
92  NULL
93 };
94 
95 static const char * const bkpt_names[] =
96 {
97  "_start",
98  "__start",
99  "main",
100  NULL
101 };
102 
103 static const char * const main_name_list[] =
104 {
105  "main_$main",
106  NULL
107 };
108 
109 /* What to do when a probe stop occurs. */
110 
112 {
113  /* Something went seriously wrong. Stop using probes and
114  revert to using the older interface. */
116 
117  /* No action is required. The shared object list is still
118  valid. */
120 
121  /* The shared object list should be reloaded entirely. */
123 
124  /* Attempt to incrementally update the shared object list. If
125  the update fails or is not possible, fall back to reloading
126  the list in full. */
128 };
129 
130 /* A probe's name and its associated action. */
131 
132 struct probe_info
133 {
134  /* The name of the probe. */
135  const char *name;
136 
137  /* What to do when a probe stop occurs. */
139 };
140 
141 /* A list of named probes and their associated actions. If all
142  probes are present in the dynamic linker then the probes-based
143  interface will be used. */
144 
145 static const struct probe_info probe_info[] =
146 {
147  { "init_start", DO_NOTHING },
148  { "init_complete", FULL_RELOAD },
149  { "map_start", DO_NOTHING },
150  { "map_failed", DO_NOTHING },
151  { "reloc_complete", UPDATE_OR_RELOAD },
152  { "unmap_start", DO_NOTHING },
153  { "unmap_complete", FULL_RELOAD },
154 };
155 
156 #define NUM_PROBES ARRAY_SIZE (probe_info)
157 
158 /* Return non-zero if GDB_SO_NAME and INFERIOR_SO_NAME represent
159  the same shared library. */
160 
161 static int
162 svr4_same_1 (const char *gdb_so_name, const char *inferior_so_name)
163 {
164  if (strcmp (gdb_so_name, inferior_so_name) == 0)
165  return 1;
166 
167  /* On Solaris, when starting inferior we think that dynamic linker is
168  /usr/lib/ld.so.1, but later on, the table of loaded shared libraries
169  contains /lib/ld.so.1. Sometimes one file is a link to another, but
170  sometimes they have identical content, but are not linked to each
171  other. We don't restrict this check for Solaris, but the chances
172  of running into this situation elsewhere are very low. */
173  if (strcmp (gdb_so_name, "/usr/lib/ld.so.1") == 0
174  && strcmp (inferior_so_name, "/lib/ld.so.1") == 0)
175  return 1;
176 
177  /* Similarly, we observed the same issue with sparc64, but with
178  different locations. */
179  if (strcmp (gdb_so_name, "/usr/lib/sparcv9/ld.so.1") == 0
180  && strcmp (inferior_so_name, "/lib/sparcv9/ld.so.1") == 0)
181  return 1;
182 
183  return 0;
184 }
185 
186 static int
188 {
189  return (svr4_same_1 (gdb->so_original_name, inferior->so_original_name));
190 }
191 
192 static struct lm_info *
194 {
196  gdb_byte *lm;
197  struct lm_info *lm_info;
198  struct cleanup *back_to;
199 
200  lm = xmalloc (lmo->link_map_size);
201  back_to = make_cleanup (xfree, lm);
202 
203  if (target_read_memory (lm_addr, lm, lmo->link_map_size) != 0)
204  {
205  warning (_("Error reading shared library list entry at %s"),
206  paddress (target_gdbarch (), lm_addr)),
207  lm_info = NULL;
208  }
209  else
210  {
211  struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
212 
213  lm_info = xzalloc (sizeof (*lm_info));
214  lm_info->lm_addr = lm_addr;
215 
217  ptr_type);
218  lm_info->l_ld = extract_typed_address (&lm[lmo->l_ld_offset], ptr_type);
219  lm_info->l_next = extract_typed_address (&lm[lmo->l_next_offset],
220  ptr_type);
221  lm_info->l_prev = extract_typed_address (&lm[lmo->l_prev_offset],
222  ptr_type);
223  lm_info->l_name = extract_typed_address (&lm[lmo->l_name_offset],
224  ptr_type);
225  }
226 
227  do_cleanups (back_to);
228 
229  return lm_info;
230 }
231 
232 static int
234 {
236 
237  return lmo->l_ld_offset >= 0;
238 }
239 
240 static CORE_ADDR
241 lm_addr_check (const struct so_list *so, bfd *abfd)
242 {
243  if (!so->lm_info->l_addr_p)
244  {
245  struct bfd_section *dyninfo_sect;
246  CORE_ADDR l_addr, l_dynaddr, dynaddr;
247 
248  l_addr = so->lm_info->l_addr_inferior;
249 
250  if (! abfd || ! has_lm_dynamic_from_link_map ())
251  goto set_addr;
252 
253  l_dynaddr = so->lm_info->l_ld;
254 
255  dyninfo_sect = bfd_get_section_by_name (abfd, ".dynamic");
256  if (dyninfo_sect == NULL)
257  goto set_addr;
258 
259  dynaddr = bfd_section_vma (abfd, dyninfo_sect);
260 
261  if (dynaddr + l_addr != l_dynaddr)
262  {
263  CORE_ADDR align = 0x1000;
264  CORE_ADDR minpagesize = align;
265 
266  if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
267  {
268  Elf_Internal_Ehdr *ehdr = elf_tdata (abfd)->elf_header;
269  Elf_Internal_Phdr *phdr = elf_tdata (abfd)->phdr;
270  int i;
271 
272  align = 1;
273 
274  for (i = 0; i < ehdr->e_phnum; i++)
275  if (phdr[i].p_type == PT_LOAD && phdr[i].p_align > align)
276  align = phdr[i].p_align;
277 
278  minpagesize = get_elf_backend_data (abfd)->minpagesize;
279  }
280 
281  /* Turn it into a mask. */
282  align--;
283 
284  /* If the changes match the alignment requirements, we
285  assume we're using a core file that was generated by the
286  same binary, just prelinked with a different base offset.
287  If it doesn't match, we may have a different binary, the
288  same binary with the dynamic table loaded at an unrelated
289  location, or anything, really. To avoid regressions,
290  don't adjust the base offset in the latter case, although
291  odds are that, if things really changed, debugging won't
292  quite work.
293 
294  One could expect more the condition
295  ((l_addr & align) == 0 && ((l_dynaddr - dynaddr) & align) == 0)
296  but the one below is relaxed for PPC. The PPC kernel supports
297  either 4k or 64k page sizes. To be prepared for 64k pages,
298  PPC ELF files are built using an alignment requirement of 64k.
299  However, when running on a kernel supporting 4k pages, the memory
300  mapping of the library may not actually happen on a 64k boundary!
301 
302  (In the usual case where (l_addr & align) == 0, this check is
303  equivalent to the possibly expected check above.)
304 
305  Even on PPC it must be zero-aligned at least for MINPAGESIZE. */
306 
307  l_addr = l_dynaddr - dynaddr;
308 
309  if ((l_addr & (minpagesize - 1)) == 0
310  && (l_addr & align) == ((l_dynaddr - dynaddr) & align))
311  {
312  if (info_verbose)
313  printf_unfiltered (_("Using PIC (Position Independent Code) "
314  "prelink displacement %s for \"%s\".\n"),
315  paddress (target_gdbarch (), l_addr),
316  so->so_name);
317  }
318  else
319  {
320  /* There is no way to verify the library file matches. prelink
321  can during prelinking of an unprelinked file (or unprelinking
322  of a prelinked file) shift the DYNAMIC segment by arbitrary
323  offset without any page size alignment. There is no way to
324  find out the ELF header and/or Program Headers for a limited
325  verification if it they match. One could do a verification
326  of the DYNAMIC segment. Still the found address is the best
327  one GDB could find. */
328 
329  warning (_(".dynamic section for \"%s\" "
330  "is not at the expected address "
331  "(wrong library or version mismatch?)"), so->so_name);
332  }
333  }
334 
335  set_addr:
336  so->lm_info->l_addr = l_addr;
337  so->lm_info->l_addr_p = 1;
338  }
339 
340  return so->lm_info->l_addr;
341 }
342 
343 /* Per pspace SVR4 specific data. */
344 
345 struct svr4_info
346 {
347  CORE_ADDR debug_base; /* Base of dynamic linker structures. */
348 
349  /* Validity flag for debug_loader_offset. */
351 
352  /* Load address for the dynamic linker, inferred. */
354 
355  /* Name of the dynamic linker, valid if debug_loader_offset_p. */
357 
358  /* Load map address for the main executable. */
360 
365 
366  /* Nonzero if the list of objects was last obtained from the target
367  via qXfer:libraries-svr4:read. */
369 
370  /* Table of struct probe_and_action instances, used by the
371  probes-based interface to map breakpoint addresses to probes
372  and their associated actions. Lookup is performed using
373  probe_and_action->probe->address. */
374  htab_t probes_table;
375 
376  /* List of objects loaded into the inferior, used by the probes-
377  based interface. */
379 };
380 
381 /* Per-program-space data key. */
382 static const struct program_space_data *solib_svr4_pspace_data;
383 
384 /* Free the probes table. */
385 
386 static void
388 {
389  if (info->probes_table == NULL)
390  return;
391 
392  htab_delete (info->probes_table);
393  info->probes_table = NULL;
394 }
395 
396 /* Free the solib list. */
397 
398 static void
400 {
402  info->solib_list = NULL;
403 }
404 
405 static void
406 svr4_pspace_data_cleanup (struct program_space *pspace, void *arg)
407 {
408  struct svr4_info *info = arg;
409 
410  free_probes_table (info);
411  free_solib_list (info);
412 
413  xfree (info);
414 }
415 
416 /* Get the current svr4 data. If none is found yet, add it now. This
417  function always returns a valid object. */
418 
419 static struct svr4_info *
421 {
422  struct svr4_info *info;
423 
424  info = program_space_data (current_program_space, solib_svr4_pspace_data);
425  if (info != NULL)
426  return info;
427 
428  info = XCNEW (struct svr4_info);
429  set_program_space_data (current_program_space, solib_svr4_pspace_data, info);
430  return info;
431 }
432 
433 /* Local function prototypes */
434 
435 static int match_main (const char *);
436 
437 /* Read program header TYPE from inferior memory. The header is found
438  by scanning the OS auxillary vector.
439 
440  If TYPE == -1, return the program headers instead of the contents of
441  one program header.
442 
443  Return a pointer to allocated memory holding the program header contents,
444  or NULL on failure. If sucessful, and unless P_SECT_SIZE is NULL, the
445  size of those contents is returned to P_SECT_SIZE. Likewise, the target
446  architecture size (32-bit or 64-bit) is returned to P_ARCH_SIZE. */
447 
448 static gdb_byte *
449 read_program_header (int type, int *p_sect_size, int *p_arch_size)
450 {
451  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
452  CORE_ADDR at_phdr, at_phent, at_phnum, pt_phdr = 0;
453  int arch_size, sect_size;
454  CORE_ADDR sect_addr;
455  gdb_byte *buf;
456  int pt_phdr_p = 0;
457 
458  /* Get required auxv elements from target. */
459  if (target_auxv_search (&current_target, AT_PHDR, &at_phdr) <= 0)
460  return 0;
461  if (target_auxv_search (&current_target, AT_PHENT, &at_phent) <= 0)
462  return 0;
463  if (target_auxv_search (&current_target, AT_PHNUM, &at_phnum) <= 0)
464  return 0;
465  if (!at_phdr || !at_phnum)
466  return 0;
467 
468  /* Determine ELF architecture type. */
469  if (at_phent == sizeof (Elf32_External_Phdr))
470  arch_size = 32;
471  else if (at_phent == sizeof (Elf64_External_Phdr))
472  arch_size = 64;
473  else
474  return 0;
475 
476  /* Find the requested segment. */
477  if (type == -1)
478  {
479  sect_addr = at_phdr;
480  sect_size = at_phent * at_phnum;
481  }
482  else if (arch_size == 32)
483  {
484  Elf32_External_Phdr phdr;
485  int i;
486 
487  /* Search for requested PHDR. */
488  for (i = 0; i < at_phnum; i++)
489  {
490  int p_type;
491 
492  if (target_read_memory (at_phdr + i * sizeof (phdr),
493  (gdb_byte *)&phdr, sizeof (phdr)))
494  return 0;
495 
496  p_type = extract_unsigned_integer ((gdb_byte *) phdr.p_type,
497  4, byte_order);
498 
499  if (p_type == PT_PHDR)
500  {
501  pt_phdr_p = 1;
502  pt_phdr = extract_unsigned_integer ((gdb_byte *) phdr.p_vaddr,
503  4, byte_order);
504  }
505 
506  if (p_type == type)
507  break;
508  }
509 
510  if (i == at_phnum)
511  return 0;
512 
513  /* Retrieve address and size. */
514  sect_addr = extract_unsigned_integer ((gdb_byte *)phdr.p_vaddr,
515  4, byte_order);
516  sect_size = extract_unsigned_integer ((gdb_byte *)phdr.p_memsz,
517  4, byte_order);
518  }
519  else
520  {
521  Elf64_External_Phdr phdr;
522  int i;
523 
524  /* Search for requested PHDR. */
525  for (i = 0; i < at_phnum; i++)
526  {
527  int p_type;
528 
529  if (target_read_memory (at_phdr + i * sizeof (phdr),
530  (gdb_byte *)&phdr, sizeof (phdr)))
531  return 0;
532 
533  p_type = extract_unsigned_integer ((gdb_byte *) phdr.p_type,
534  4, byte_order);
535 
536  if (p_type == PT_PHDR)
537  {
538  pt_phdr_p = 1;
539  pt_phdr = extract_unsigned_integer ((gdb_byte *) phdr.p_vaddr,
540  8, byte_order);
541  }
542 
543  if (p_type == type)
544  break;
545  }
546 
547  if (i == at_phnum)
548  return 0;
549 
550  /* Retrieve address and size. */
551  sect_addr = extract_unsigned_integer ((gdb_byte *)phdr.p_vaddr,
552  8, byte_order);
553  sect_size = extract_unsigned_integer ((gdb_byte *)phdr.p_memsz,
554  8, byte_order);
555  }
556 
557  /* PT_PHDR is optional, but we really need it
558  for PIE to make this work in general. */
559 
560  if (pt_phdr_p)
561  {
562  /* at_phdr is real address in memory. pt_phdr is what pheader says it is.
563  Relocation offset is the difference between the two. */
564  sect_addr = sect_addr + (at_phdr - pt_phdr);
565  }
566 
567  /* Read in requested program header. */
568  buf = xmalloc (sect_size);
569  if (target_read_memory (sect_addr, buf, sect_size))
570  {
571  xfree (buf);
572  return NULL;
573  }
574 
575  if (p_arch_size)
576  *p_arch_size = arch_size;
577  if (p_sect_size)
578  *p_sect_size = sect_size;
579 
580  return buf;
581 }
582 
583 
584 /* Return program interpreter string. */
585 static char *
587 {
588  gdb_byte *buf = NULL;
589 
590  /* If we have an exec_bfd, use its section table. */
591  if (exec_bfd
592  && bfd_get_flavour (exec_bfd) == bfd_target_elf_flavour)
593  {
594  struct bfd_section *interp_sect;
595 
596  interp_sect = bfd_get_section_by_name (exec_bfd, ".interp");
597  if (interp_sect != NULL)
598  {
599  int sect_size = bfd_section_size (exec_bfd, interp_sect);
600 
601  buf = xmalloc (sect_size);
602  bfd_get_section_contents (exec_bfd, interp_sect, buf, 0, sect_size);
603  }
604  }
605 
606  /* If we didn't find it, use the target auxillary vector. */
607  if (!buf)
608  buf = read_program_header (PT_INTERP, NULL, NULL);
609 
610  return (char *) buf;
611 }
612 
613 
614 /* Scan for DESIRED_DYNTAG in .dynamic section of ABFD. If DESIRED_DYNTAG is
615  found, 1 is returned and the corresponding PTR is set. */
616 
617 static int
618 scan_dyntag (const int desired_dyntag, bfd *abfd, CORE_ADDR *ptr)
619 {
620  int arch_size, step, sect_size;
621  long current_dyntag;
622  CORE_ADDR dyn_ptr, dyn_addr;
623  gdb_byte *bufend, *bufstart, *buf;
624  Elf32_External_Dyn *x_dynp_32;
625  Elf64_External_Dyn *x_dynp_64;
626  struct bfd_section *sect;
628 
629  if (abfd == NULL)
630  return 0;
631 
632  if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
633  return 0;
634 
635  arch_size = bfd_get_arch_size (abfd);
636  if (arch_size == -1)
637  return 0;
638 
639  /* Find the start address of the .dynamic section. */
640  sect = bfd_get_section_by_name (abfd, ".dynamic");
641  if (sect == NULL)
642  return 0;
643 
644  for (target_section = current_target_sections->sections;
646  target_section++)
647  if (sect == target_section->the_bfd_section)
648  break;
650  dyn_addr = target_section->addr;
651  else
652  {
653  /* ABFD may come from OBJFILE acting only as a symbol file without being
654  loaded into the target (see add_symbol_file_command). This case is
655  such fallback to the file VMA address without the possibility of
656  having the section relocated to its actual in-memory address. */
657 
658  dyn_addr = bfd_section_vma (abfd, sect);
659  }
660 
661  /* Read in .dynamic from the BFD. We will get the actual value
662  from memory later. */
663  sect_size = bfd_section_size (abfd, sect);
664  buf = bufstart = alloca (sect_size);
665  if (!bfd_get_section_contents (abfd, sect,
666  buf, 0, sect_size))
667  return 0;
668 
669  /* Iterate over BUF and scan for DYNTAG. If found, set PTR and return. */
670  step = (arch_size == 32) ? sizeof (Elf32_External_Dyn)
671  : sizeof (Elf64_External_Dyn);
672  for (bufend = buf + sect_size;
673  buf < bufend;
674  buf += step)
675  {
676  if (arch_size == 32)
677  {
678  x_dynp_32 = (Elf32_External_Dyn *) buf;
679  current_dyntag = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp_32->d_tag);
680  dyn_ptr = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp_32->d_un.d_ptr);
681  }
682  else
683  {
684  x_dynp_64 = (Elf64_External_Dyn *) buf;
685  current_dyntag = bfd_h_get_64 (abfd, (bfd_byte *) x_dynp_64->d_tag);
686  dyn_ptr = bfd_h_get_64 (abfd, (bfd_byte *) x_dynp_64->d_un.d_ptr);
687  }
688  if (current_dyntag == DT_NULL)
689  return 0;
690  if (current_dyntag == desired_dyntag)
691  {
692  /* If requested, try to read the runtime value of this .dynamic
693  entry. */
694  if (ptr)
695  {
696  struct type *ptr_type;
697  gdb_byte ptr_buf[8];
698  CORE_ADDR ptr_addr;
699 
701  ptr_addr = dyn_addr + (buf - bufstart) + arch_size / 8;
702  if (target_read_memory (ptr_addr, ptr_buf, arch_size / 8) == 0)
703  dyn_ptr = extract_typed_address (ptr_buf, ptr_type);
704  *ptr = dyn_ptr;
705  }
706  return 1;
707  }
708  }
709 
710  return 0;
711 }
712 
713 /* Scan for DESIRED_DYNTAG in .dynamic section of the target's main executable,
714  found by consulting the OS auxillary vector. If DESIRED_DYNTAG is found, 1
715  is returned and the corresponding PTR is set. */
716 
717 static int
718 scan_dyntag_auxv (const int desired_dyntag, CORE_ADDR *ptr)
719 {
720  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
721  int sect_size, arch_size, step;
722  long current_dyntag;
723  CORE_ADDR dyn_ptr;
724  gdb_byte *bufend, *bufstart, *buf;
725 
726  /* Read in .dynamic section. */
727  buf = bufstart = read_program_header (PT_DYNAMIC, &sect_size, &arch_size);
728  if (!buf)
729  return 0;
730 
731  /* Iterate over BUF and scan for DYNTAG. If found, set PTR and return. */
732  step = (arch_size == 32) ? sizeof (Elf32_External_Dyn)
733  : sizeof (Elf64_External_Dyn);
734  for (bufend = buf + sect_size;
735  buf < bufend;
736  buf += step)
737  {
738  if (arch_size == 32)
739  {
740  Elf32_External_Dyn *dynp = (Elf32_External_Dyn *) buf;
741 
742  current_dyntag = extract_unsigned_integer ((gdb_byte *) dynp->d_tag,
743  4, byte_order);
744  dyn_ptr = extract_unsigned_integer ((gdb_byte *) dynp->d_un.d_ptr,
745  4, byte_order);
746  }
747  else
748  {
749  Elf64_External_Dyn *dynp = (Elf64_External_Dyn *) buf;
750 
751  current_dyntag = extract_unsigned_integer ((gdb_byte *) dynp->d_tag,
752  8, byte_order);
753  dyn_ptr = extract_unsigned_integer ((gdb_byte *) dynp->d_un.d_ptr,
754  8, byte_order);
755  }
756  if (current_dyntag == DT_NULL)
757  break;
758 
759  if (current_dyntag == desired_dyntag)
760  {
761  if (ptr)
762  *ptr = dyn_ptr;
763 
764  xfree (bufstart);
765  return 1;
766  }
767  }
768 
769  xfree (bufstart);
770  return 0;
771 }
772 
773 /* Locate the base address of dynamic linker structs for SVR4 elf
774  targets.
775 
776  For SVR4 elf targets the address of the dynamic linker's runtime
777  structure is contained within the dynamic info section in the
778  executable file. The dynamic section is also mapped into the
779  inferior address space. Because the runtime loader fills in the
780  real address before starting the inferior, we have to read in the
781  dynamic info section from the inferior address space.
782  If there are any errors while trying to find the address, we
783  silently return 0, otherwise the found address is returned. */
784 
785 static CORE_ADDR
787 {
788  struct bound_minimal_symbol msymbol;
789  CORE_ADDR dyn_ptr;
790 
791  /* Look for DT_MIPS_RLD_MAP first. MIPS executables use this
792  instead of DT_DEBUG, although they sometimes contain an unused
793  DT_DEBUG. */
794  if (scan_dyntag (DT_MIPS_RLD_MAP, exec_bfd, &dyn_ptr)
795  || scan_dyntag_auxv (DT_MIPS_RLD_MAP, &dyn_ptr))
796  {
797  struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
798  gdb_byte *pbuf;
799  int pbuf_size = TYPE_LENGTH (ptr_type);
800 
801  pbuf = alloca (pbuf_size);
802  /* DT_MIPS_RLD_MAP contains a pointer to the address
803  of the dynamic link structure. */
804  if (target_read_memory (dyn_ptr, pbuf, pbuf_size))
805  return 0;
806  return extract_typed_address (pbuf, ptr_type);
807  }
808 
809  /* Find DT_DEBUG. */
810  if (scan_dyntag (DT_DEBUG, exec_bfd, &dyn_ptr)
811  || scan_dyntag_auxv (DT_DEBUG, &dyn_ptr))
812  return dyn_ptr;
813 
814  /* This may be a static executable. Look for the symbol
815  conventionally named _r_debug, as a last resort. */
816  msymbol = lookup_minimal_symbol ("_r_debug", NULL, symfile_objfile);
817  if (msymbol.minsym != NULL)
818  return BMSYMBOL_VALUE_ADDRESS (msymbol);
819 
820  /* DT_DEBUG entry not found. */
821  return 0;
822 }
823 
824 /* Locate the base address of dynamic linker structs.
825 
826  For both the SunOS and SVR4 shared library implementations, if the
827  inferior executable has been linked dynamically, there is a single
828  address somewhere in the inferior's data space which is the key to
829  locating all of the dynamic linker's runtime structures. This
830  address is the value of the debug base symbol. The job of this
831  function is to find and return that address, or to return 0 if there
832  is no such address (the executable is statically linked for example).
833 
834  For SunOS, the job is almost trivial, since the dynamic linker and
835  all of it's structures are statically linked to the executable at
836  link time. Thus the symbol for the address we are looking for has
837  already been added to the minimal symbol table for the executable's
838  objfile at the time the symbol file's symbols were read, and all we
839  have to do is look it up there. Note that we explicitly do NOT want
840  to find the copies in the shared library.
841 
842  The SVR4 version is a bit more complicated because the address
843  is contained somewhere in the dynamic info section. We have to go
844  to a lot more work to discover the address of the debug base symbol.
845  Because of this complexity, we cache the value we find and return that
846  value on subsequent invocations. Note there is no copy in the
847  executable symbol tables. */
848 
849 static CORE_ADDR
850 locate_base (struct svr4_info *info)
851 {
852  /* Check to see if we have a currently valid address, and if so, avoid
853  doing all this work again and just return the cached address. If
854  we have no cached address, try to locate it in the dynamic info
855  section for ELF executables. There's no point in doing any of this
856  though if we don't have some link map offsets to work with. */
857 
858  if (info->debug_base == 0 && svr4_have_link_map_offsets ())
859  info->debug_base = elf_locate_base ();
860  return info->debug_base;
861 }
862 
863 /* Find the first element in the inferior's dynamic link map, and
864  return its address in the inferior. Return zero if the address
865  could not be determined.
866 
867  FIXME: Perhaps we should validate the info somehow, perhaps by
868  checking r_version for a known version number, or r_state for
869  RT_CONSISTENT. */
870 
871 static CORE_ADDR
873 {
875  struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
876  CORE_ADDR addr = 0;
877 
878  TRY
879  {
881  ptr_type);
882  }
884  {
886  }
887  END_CATCH
888 
889  return addr;
890 }
891 
892 /* Find r_brk from the inferior's debug base. */
893 
894 static CORE_ADDR
896 {
898  struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
899 
901  ptr_type);
902 }
903 
904 /* Find the link map for the dynamic linker (if it is not in the
905  normal list of loaded shared objects). */
906 
907 static CORE_ADDR
909 {
911  struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
912  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
913  ULONGEST version = 0;
914 
915  TRY
916  {
917  /* Check version, and return zero if `struct r_debug' doesn't have
918  the r_ldsomap member. */
919  version
921  lmo->r_version_size, byte_order);
922  }
924  {
926  }
927  END_CATCH
928 
929  if (version < 2 || lmo->r_ldsomap_offset == -1)
930  return 0;
931 
933  ptr_type);
934 }
935 
936 /* On Solaris systems with some versions of the dynamic linker,
937  ld.so's l_name pointer points to the SONAME in the string table
938  rather than into writable memory. So that GDB can find shared
939  libraries when loading a core file generated by gcore, ensure that
940  memory areas containing the l_name string are saved in the core
941  file. */
942 
943 static int
944 svr4_keep_data_in_core (CORE_ADDR vaddr, unsigned long size)
945 {
946  struct svr4_info *info;
947  CORE_ADDR ldsomap;
948  struct so_list *newobj;
949  struct cleanup *old_chain;
950  CORE_ADDR name_lm;
951 
952  info = get_svr4_info ();
953 
954  info->debug_base = 0;
955  locate_base (info);
956  if (!info->debug_base)
957  return 0;
958 
959  ldsomap = solib_svr4_r_ldsomap (info);
960  if (!ldsomap)
961  return 0;
962 
963  newobj = XCNEW (struct so_list);
964  old_chain = make_cleanup (xfree, newobj);
965  newobj->lm_info = lm_info_read (ldsomap);
966  make_cleanup (xfree, newobj->lm_info);
967  name_lm = newobj->lm_info ? newobj->lm_info->l_name : 0;
968  do_cleanups (old_chain);
969 
970  return (name_lm >= vaddr && name_lm < vaddr + size);
971 }
972 
973 /* Implement the "open_symbol_file_object" target_so_ops method.
974 
975  If no open symbol file, attempt to locate and open the main symbol
976  file. On SVR4 systems, this is the first link map entry. If its
977  name is here, we can open it. Useful when attaching to a process
978  without first loading its symbol file. */
979 
980 static int
981 open_symbol_file_object (void *from_ttyp)
982 {
983  CORE_ADDR lm, l_name;
984  char *filename;
985  int errcode;
986  int from_tty = *(int *)from_ttyp;
988  struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
989  int l_name_size = TYPE_LENGTH (ptr_type);
990  gdb_byte *l_name_buf = xmalloc (l_name_size);
991  struct cleanup *cleanups = make_cleanup (xfree, l_name_buf);
992  struct svr4_info *info = get_svr4_info ();
993 
994  if (symfile_objfile)
995  if (!query (_("Attempt to reload symbols from process? ")))
996  {
997  do_cleanups (cleanups);
998  return 0;
999  }
1000 
1001  /* Always locate the debug struct, in case it has moved. */
1002  info->debug_base = 0;
1003  if (locate_base (info) == 0)
1004  {
1005  do_cleanups (cleanups);
1006  return 0; /* failed somehow... */
1007  }
1008 
1009  /* First link map member should be the executable. */
1010  lm = solib_svr4_r_map (info);
1011  if (lm == 0)
1012  {
1013  do_cleanups (cleanups);
1014  return 0; /* failed somehow... */
1015  }
1016 
1017  /* Read address of name from target memory to GDB. */
1018  read_memory (lm + lmo->l_name_offset, l_name_buf, l_name_size);
1019 
1020  /* Convert the address to host format. */
1021  l_name = extract_typed_address (l_name_buf, ptr_type);
1022 
1023  if (l_name == 0)
1024  {
1025  do_cleanups (cleanups);
1026  return 0; /* No filename. */
1027  }
1028 
1029  /* Now fetch the filename from target memory. */
1030  target_read_string (l_name, &filename, SO_NAME_MAX_PATH_SIZE - 1, &errcode);
1031  make_cleanup (xfree, filename);
1032 
1033  if (errcode)
1034  {
1035  warning (_("failed to read exec filename from attached file: %s"),
1036  safe_strerror (errcode));
1037  do_cleanups (cleanups);
1038  return 0;
1039  }
1040 
1041  /* Have a pathname: read the symbol file. */
1042  symbol_file_add_main (filename, from_tty);
1043 
1044  do_cleanups (cleanups);
1045  return 1;
1046 }
1047 
1048 /* Data exchange structure for the XML parser as returned by
1049  svr4_current_sos_via_xfer_libraries. */
1050 
1052 {
1053  struct so_list *head, **tailp;
1054 
1055  /* Inferior address of struct link_map used for the main executable. It is
1056  NULL if not known. */
1058 };
1059 
1060 /* Implementation for target_so_ops.free_so. */
1061 
1062 static void
1063 svr4_free_so (struct so_list *so)
1064 {
1065  xfree (so->lm_info);
1066 }
1067 
1068 /* Implement target_so_ops.clear_so. */
1069 
1070 static void
1072 {
1073  if (so->lm_info != NULL)
1074  so->lm_info->l_addr_p = 0;
1075 }
1076 
1077 /* Free so_list built so far (called via cleanup). */
1078 
1079 static void
1081 {
1082  struct so_list *list = *(struct so_list **) p_list;
1083 
1084  while (list != NULL)
1085  {
1086  struct so_list *next = list->next;
1087 
1088  free_so (list);
1089  list = next;
1090  }
1091 }
1092 
1093 /* Copy library list. */
1094 
1095 static struct so_list *
1097 {
1098  struct so_list *dst = NULL;
1099  struct so_list **link = &dst;
1100 
1101  while (src != NULL)
1102  {
1103  struct so_list *newobj;
1104 
1105  newobj = xmalloc (sizeof (struct so_list));
1106  memcpy (newobj, src, sizeof (struct so_list));
1107 
1108  newobj->lm_info = xmalloc (sizeof (struct lm_info));
1109  memcpy (newobj->lm_info, src->lm_info, sizeof (struct lm_info));
1110 
1111  newobj->next = NULL;
1112  *link = newobj;
1113  link = &newobj->next;
1114 
1115  src = src->next;
1116  }
1117 
1118  return dst;
1119 }
1120 
1121 #ifdef HAVE_LIBEXPAT
1122 
1123 #include "xml-support.h"
1124 
1125 /* Handle the start of a <library> element. Note: new elements are added
1126  at the tail of the list, keeping the list in order. */
1127 
1128 static void
1130  const struct gdb_xml_element *element,
1131  void *user_data, VEC(gdb_xml_value_s) *attributes)
1132 {
1133  struct svr4_library_list *list = user_data;
1134  const char *name = xml_find_attribute (attributes, "name")->value;
1135  ULONGEST *lmp = xml_find_attribute (attributes, "lm")->value;
1136  ULONGEST *l_addrp = xml_find_attribute (attributes, "l_addr")->value;
1137  ULONGEST *l_ldp = xml_find_attribute (attributes, "l_ld")->value;
1138  struct so_list *new_elem;
1139 
1140  new_elem = XCNEW (struct so_list);
1141  new_elem->lm_info = XCNEW (struct lm_info);
1142  new_elem->lm_info->lm_addr = *lmp;
1143  new_elem->lm_info->l_addr_inferior = *l_addrp;
1144  new_elem->lm_info->l_ld = *l_ldp;
1145 
1146  strncpy (new_elem->so_name, name, sizeof (new_elem->so_name) - 1);
1147  new_elem->so_name[sizeof (new_elem->so_name) - 1] = 0;
1148  strcpy (new_elem->so_original_name, new_elem->so_name);
1149 
1150  *list->tailp = new_elem;
1151  list->tailp = &new_elem->next;
1152 }
1153 
1154 /* Handle the start of a <library-list-svr4> element. */
1155 
1156 static void
1158  const struct gdb_xml_element *element,
1159  void *user_data, VEC(gdb_xml_value_s) *attributes)
1160 {
1161  struct svr4_library_list *list = user_data;
1162  const char *version = xml_find_attribute (attributes, "version")->value;
1163  struct gdb_xml_value *main_lm = xml_find_attribute (attributes, "main-lm");
1164 
1165  if (strcmp (version, "1.0") != 0)
1166  gdb_xml_error (parser,
1167  _("SVR4 Library list has unsupported version \"%s\""),
1168  version);
1169 
1170  if (main_lm)
1171  list->main_lm = *(ULONGEST *) main_lm->value;
1172 }
1173 
1174 /* The allowed elements and attributes for an XML library list.
1175  The root element is a <library-list>. */
1176 
1177 static const struct gdb_xml_attribute svr4_library_attributes[] =
1178 {
1179  { "name", GDB_XML_AF_NONE, NULL, NULL },
1181  { "l_addr", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
1182  { "l_ld", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
1183  { NULL, GDB_XML_AF_NONE, NULL, NULL }
1184 };
1185 
1186 static const struct gdb_xml_element svr4_library_list_children[] =
1187 {
1188  {
1189  "library", svr4_library_attributes, NULL,
1192  },
1193  { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
1194 };
1195 
1196 static const struct gdb_xml_attribute svr4_library_list_attributes[] =
1197 {
1198  { "version", GDB_XML_AF_NONE, NULL, NULL },
1199  { "main-lm", GDB_XML_AF_OPTIONAL, gdb_xml_parse_attr_ulongest, NULL },
1200  { NULL, GDB_XML_AF_NONE, NULL, NULL }
1201 };
1202 
1203 static const struct gdb_xml_element svr4_library_list_elements[] =
1204 {
1207  { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
1208 };
1209 
1210 /* Parse qXfer:libraries:read packet into *SO_LIST_RETURN. Return 1 if
1211 
1212  Return 0 if packet not supported, *SO_LIST_RETURN is not modified in such
1213  case. Return 1 if *SO_LIST_RETURN contains the library list, it may be
1214  empty, caller is responsible for freeing all its entries. */
1215 
1216 static int
1217 svr4_parse_libraries (const char *document, struct svr4_library_list *list)
1218 {
1219  struct cleanup *back_to = make_cleanup (svr4_free_library_list,
1220  &list->head);
1221 
1222  memset (list, 0, sizeof (*list));
1223  list->tailp = &list->head;
1224  if (gdb_xml_parse_quick (_("target library list"), "library-list-svr4.dtd",
1225  svr4_library_list_elements, document, list) == 0)
1226  {
1227  /* Parsed successfully, keep the result. */
1228  discard_cleanups (back_to);
1229  return 1;
1230  }
1231 
1232  do_cleanups (back_to);
1233  return 0;
1234 }
1235 
1236 /* Attempt to get so_list from target via qXfer:libraries-svr4:read packet.
1237 
1238  Return 0 if packet not supported, *SO_LIST_RETURN is not modified in such
1239  case. Return 1 if *SO_LIST_RETURN contains the library list, it may be
1240  empty, caller is responsible for freeing all its entries.
1241 
1242  Note that ANNEX must be NULL if the remote does not explicitly allow
1243  qXfer:libraries-svr4:read packets with non-empty annexes. Support for
1244  this can be checked using target_augmented_libraries_svr4_read (). */
1245 
1246 static int
1248  const char *annex)
1249 {
1250  char *svr4_library_document;
1251  int result;
1252  struct cleanup *back_to;
1253 
1254  gdb_assert (annex == NULL || target_augmented_libraries_svr4_read ());
1255 
1256  /* Fetch the list of shared libraries. */
1257  svr4_library_document = target_read_stralloc (&current_target,
1259  annex);
1260  if (svr4_library_document == NULL)
1261  return 0;
1262 
1263  back_to = make_cleanup (xfree, svr4_library_document);
1264  result = svr4_parse_libraries (svr4_library_document, list);
1265  do_cleanups (back_to);
1266 
1267  return result;
1268 }
1269 
1270 #else
1271 
1272 static int
1274  const char *annex)
1275 {
1276  return 0;
1277 }
1278 
1279 #endif
1280 
1281 /* If no shared library information is available from the dynamic
1282  linker, build a fallback list from other sources. */
1283 
1284 static struct so_list *
1286 {
1287  struct svr4_info *info = get_svr4_info ();
1288  struct so_list *newobj;
1289 
1290  if (!info->debug_loader_offset_p)
1291  return NULL;
1292 
1293  newobj = XCNEW (struct so_list);
1294 
1295  newobj->lm_info = xzalloc (sizeof (struct lm_info));
1296 
1297  /* Nothing will ever check the other fields if we set l_addr_p. */
1298  newobj->lm_info->l_addr = info->debug_loader_offset;
1299  newobj->lm_info->l_addr_p = 1;
1300 
1301  strncpy (newobj->so_name, info->debug_loader_name, SO_NAME_MAX_PATH_SIZE - 1);
1302  newobj->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
1303  strcpy (newobj->so_original_name, newobj->so_name);
1304 
1305  return newobj;
1306 }
1307 
1308 /* Read the whole inferior libraries chain starting at address LM.
1309  Expect the first entry in the chain's previous entry to be PREV_LM.
1310  Add the entries to the tail referenced by LINK_PTR_PTR. Ignore the
1311  first entry if IGNORE_FIRST and set global MAIN_LM_ADDR according
1312  to it. Returns nonzero upon success. If zero is returned the
1313  entries stored to LINK_PTR_PTR are still valid although they may
1314  represent only part of the inferior library list. */
1315 
1316 static int
1318  struct so_list ***link_ptr_ptr, int ignore_first)
1319 {
1320  CORE_ADDR first_l_name = 0;
1321  CORE_ADDR next_lm;
1322 
1323  for (; lm != 0; prev_lm = lm, lm = next_lm)
1324  {
1325  struct so_list *newobj;
1326  struct cleanup *old_chain;
1327  int errcode;
1328  char *buffer;
1329 
1330  newobj = XCNEW (struct so_list);
1331  old_chain = make_cleanup_free_so (newobj);
1332 
1333  newobj->lm_info = lm_info_read (lm);
1334  if (newobj->lm_info == NULL)
1335  {
1336  do_cleanups (old_chain);
1337  return 0;
1338  }
1339 
1340  next_lm = newobj->lm_info->l_next;
1341 
1342  if (newobj->lm_info->l_prev != prev_lm)
1343  {
1344  warning (_("Corrupted shared library list: %s != %s"),
1345  paddress (target_gdbarch (), prev_lm),
1346  paddress (target_gdbarch (), newobj->lm_info->l_prev));
1347  do_cleanups (old_chain);
1348  return 0;
1349  }
1350 
1351  /* For SVR4 versions, the first entry in the link map is for the
1352  inferior executable, so we must ignore it. For some versions of
1353  SVR4, it has no name. For others (Solaris 2.3 for example), it
1354  does have a name, so we can no longer use a missing name to
1355  decide when to ignore it. */
1356  if (ignore_first && newobj->lm_info->l_prev == 0)
1357  {
1358  struct svr4_info *info = get_svr4_info ();
1359 
1360  first_l_name = newobj->lm_info->l_name;
1361  info->main_lm_addr = newobj->lm_info->lm_addr;
1362  do_cleanups (old_chain);
1363  continue;
1364  }
1365 
1366  /* Extract this shared object's name. */
1367  target_read_string (newobj->lm_info->l_name, &buffer,
1368  SO_NAME_MAX_PATH_SIZE - 1, &errcode);
1369  if (errcode != 0)
1370  {
1371  /* If this entry's l_name address matches that of the
1372  inferior executable, then this is not a normal shared
1373  object, but (most likely) a vDSO. In this case, silently
1374  skip it; otherwise emit a warning. */
1375  if (first_l_name == 0 || newobj->lm_info->l_name != first_l_name)
1376  warning (_("Can't read pathname for load map: %s."),
1377  safe_strerror (errcode));
1378  do_cleanups (old_chain);
1379  continue;
1380  }
1381 
1382  strncpy (newobj->so_name, buffer, SO_NAME_MAX_PATH_SIZE - 1);
1383  newobj->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
1384  strcpy (newobj->so_original_name, newobj->so_name);
1385  xfree (buffer);
1386 
1387  /* If this entry has no name, or its name matches the name
1388  for the main executable, don't include it in the list. */
1389  if (! newobj->so_name[0] || match_main (newobj->so_name))
1390  {
1391  do_cleanups (old_chain);
1392  continue;
1393  }
1394 
1395  discard_cleanups (old_chain);
1396  newobj->next = 0;
1397  **link_ptr_ptr = newobj;
1398  *link_ptr_ptr = &newobj->next;
1399  }
1400 
1401  return 1;
1402 }
1403 
1404 /* Read the full list of currently loaded shared objects directly
1405  from the inferior, without referring to any libraries read and
1406  stored by the probes interface. Handle special cases relating
1407  to the first elements of the list. */
1408 
1409 static struct so_list *
1411 {
1412  CORE_ADDR lm;
1413  struct so_list *head = NULL;
1414  struct so_list **link_ptr = &head;
1415  struct cleanup *back_to;
1416  int ignore_first;
1417  struct svr4_library_list library_list;
1418 
1419  /* Fall back to manual examination of the target if the packet is not
1420  supported or gdbserver failed to find DT_DEBUG. gdb.server/solib-list.exp
1421  tests a case where gdbserver cannot find the shared libraries list while
1422  GDB itself is able to find it via SYMFILE_OBJFILE.
1423 
1424  Unfortunately statically linked inferiors will also fall back through this
1425  suboptimal code path. */
1426 
1427  info->using_xfer = svr4_current_sos_via_xfer_libraries (&library_list,
1428  NULL);
1429  if (info->using_xfer)
1430  {
1431  if (library_list.main_lm)
1432  info->main_lm_addr = library_list.main_lm;
1433 
1434  return library_list.head ? library_list.head : svr4_default_sos ();
1435  }
1436 
1437  /* Always locate the debug struct, in case it has moved. */
1438  info->debug_base = 0;
1439  locate_base (info);
1440 
1441  /* If we can't find the dynamic linker's base structure, this
1442  must not be a dynamically linked executable. Hmm. */
1443  if (! info->debug_base)
1444  return svr4_default_sos ();
1445 
1446  /* Assume that everything is a library if the dynamic loader was loaded
1447  late by a static executable. */
1448  if (exec_bfd && bfd_get_section_by_name (exec_bfd, ".dynamic") == NULL)
1449  ignore_first = 0;
1450  else
1451  ignore_first = 1;
1452 
1453  back_to = make_cleanup (svr4_free_library_list, &head);
1454 
1455  /* Walk the inferior's link map list, and build our list of
1456  `struct so_list' nodes. */
1457  lm = solib_svr4_r_map (info);
1458  if (lm)
1459  svr4_read_so_list (lm, 0, &link_ptr, ignore_first);
1460 
1461  /* On Solaris, the dynamic linker is not in the normal list of
1462  shared objects, so make sure we pick it up too. Having
1463  symbol information for the dynamic linker is quite crucial
1464  for skipping dynamic linker resolver code. */
1465  lm = solib_svr4_r_ldsomap (info);
1466  if (lm)
1467  svr4_read_so_list (lm, 0, &link_ptr, 0);
1468 
1469  discard_cleanups (back_to);
1470 
1471  if (head == NULL)
1472  return svr4_default_sos ();
1473 
1474  return head;
1475 }
1476 
1477 /* Implement the main part of the "current_sos" target_so_ops
1478  method. */
1479 
1480 static struct so_list *
1482 {
1483  struct svr4_info *info = get_svr4_info ();
1484 
1485  /* If the solib list has been read and stored by the probes
1486  interface then we return a copy of the stored list. */
1487  if (info->solib_list != NULL)
1488  return svr4_copy_library_list (info->solib_list);
1489 
1490  /* Otherwise obtain the solib list directly from the inferior. */
1491  return svr4_current_sos_direct (info);
1492 }
1493 
1494 /* Implement the "current_sos" target_so_ops method. */
1495 
1496 static struct so_list *
1498 {
1499  struct so_list *so_head = svr4_current_sos_1 ();
1500  struct mem_range vsyscall_range;
1501 
1502  /* Filter out the vDSO module, if present. Its symbol file would
1503  not be found on disk. The vDSO/vsyscall's OBJFILE is instead
1504  managed by symfile-mem.c:add_vsyscall_page. */
1505  if (gdbarch_vsyscall_range (target_gdbarch (), &vsyscall_range)
1506  && vsyscall_range.length != 0)
1507  {
1508  struct so_list **sop;
1509 
1510  sop = &so_head;
1511  while (*sop != NULL)
1512  {
1513  struct so_list *so = *sop;
1514 
1515  /* We can't simply match the vDSO by starting address alone,
1516  because lm_info->l_addr_inferior (and also l_addr) do not
1517  necessarily represent the real starting address of the
1518  ELF if the vDSO's ELF itself is "prelinked". The l_ld
1519  field (the ".dynamic" section of the shared object)
1520  always points at the absolute/resolved address though.
1521  So check whether that address is inside the vDSO's
1522  mapping instead.
1523 
1524  E.g., on Linux 3.16 (x86_64) the vDSO is a regular
1525  0-based ELF, and we see:
1526 
1527  (gdb) info auxv
1528  33 AT_SYSINFO_EHDR System-supplied DSO's ELF header 0x7ffff7ffb000
1529  (gdb) p/x *_r_debug.r_map.l_next
1530  $1 = {l_addr = 0x7ffff7ffb000, ..., l_ld = 0x7ffff7ffb318, ...}
1531 
1532  And on Linux 2.6.32 (x86_64) we see:
1533 
1534  (gdb) info auxv
1535  33 AT_SYSINFO_EHDR System-supplied DSO's ELF header 0x7ffff7ffe000
1536  (gdb) p/x *_r_debug.r_map.l_next
1537  $5 = {l_addr = 0x7ffff88fe000, ..., l_ld = 0x7ffff7ffe580, ... }
1538 
1539  Dumping that vDSO shows:
1540 
1541  (gdb) info proc mappings
1542  0x7ffff7ffe000 0x7ffff7fff000 0x1000 0 [vdso]
1543  (gdb) dump memory vdso.bin 0x7ffff7ffe000 0x7ffff7fff000
1544  # readelf -Wa vdso.bin
1545  [...]
1546  Entry point address: 0xffffffffff700700
1547  [...]
1548  Section Headers:
1549  [Nr] Name Type Address Off Size
1550  [ 0] NULL 0000000000000000 000000 000000
1551  [ 1] .hash HASH ffffffffff700120 000120 000038
1552  [ 2] .dynsym DYNSYM ffffffffff700158 000158 0000d8
1553  [...]
1554  [ 9] .dynamic DYNAMIC ffffffffff700580 000580 0000f0
1555  */
1556  if (address_in_mem_range (so->lm_info->l_ld, &vsyscall_range))
1557  {
1558  *sop = so->next;
1559  free_so (so);
1560  break;
1561  }
1562 
1563  sop = &so->next;
1564  }
1565  }
1566 
1567  return so_head;
1568 }
1569 
1570 /* Get the address of the link_map for a given OBJFILE. */
1571 
1572 CORE_ADDR
1574 {
1575  struct so_list *so;
1576  struct svr4_info *info = get_svr4_info ();
1577 
1578  /* Cause svr4_current_sos() to be run if it hasn't been already. */
1579  if (info->main_lm_addr == 0)
1581 
1582  /* svr4_current_sos() will set main_lm_addr for the main executable. */
1583  if (objfile == symfile_objfile)
1584  return info->main_lm_addr;
1585 
1586  /* The other link map addresses may be found by examining the list
1587  of shared libraries. */
1588  for (so = master_so_list (); so; so = so->next)
1589  if (so->objfile == objfile)
1590  return so->lm_info->lm_addr;
1591 
1592  /* Not found! */
1593  return 0;
1594 }
1595 
1596 /* On some systems, the only way to recognize the link map entry for
1597  the main executable file is by looking at its name. Return
1598  non-zero iff SONAME matches one of the known main executable names. */
1599 
1600 static int
1601 match_main (const char *soname)
1602 {
1603  const char * const *mainp;
1604 
1605  for (mainp = main_name_list; *mainp != NULL; mainp++)
1606  {
1607  if (strcmp (soname, *mainp) == 0)
1608  return (1);
1609  }
1610 
1611  return (0);
1612 }
1613 
1614 /* Return 1 if PC lies in the dynamic symbol resolution code of the
1615  SVR4 run time loader. */
1616 
1617 int
1619 {
1620  struct svr4_info *info = get_svr4_info ();
1621 
1622  return ((pc >= info->interp_text_sect_low
1623  && pc < info->interp_text_sect_high)
1624  || (pc >= info->interp_plt_sect_low
1625  && pc < info->interp_plt_sect_high)
1626  || in_plt_section (pc)
1627  || in_gnu_ifunc_stub (pc));
1628 }
1629 
1630 /* Given an executable's ABFD and target, compute the entry-point
1631  address. */
1632 
1633 static CORE_ADDR
1634 exec_entry_point (struct bfd *abfd, struct target_ops *targ)
1635 {
1636  CORE_ADDR addr;
1637 
1638  /* KevinB wrote ... for most targets, the address returned by
1639  bfd_get_start_address() is the entry point for the start
1640  function. But, for some targets, bfd_get_start_address() returns
1641  the address of a function descriptor from which the entry point
1642  address may be extracted. This address is extracted by
1643  gdbarch_convert_from_func_ptr_addr(). The method
1644  gdbarch_convert_from_func_ptr_addr() is the merely the identify
1645  function for targets which don't use function descriptors. */
1647  bfd_get_start_address (abfd),
1648  targ);
1649  return gdbarch_addr_bits_remove (target_gdbarch (), addr);
1650 }
1651 
1652 /* A probe and its associated action. */
1653 
1655 {
1656  /* The probe. */
1657  struct probe *probe;
1658 
1659  /* The relocated address of the probe. */
1661 
1662  /* The action. */
1664 };
1665 
1666 /* Returns a hash code for the probe_and_action referenced by p. */
1667 
1668 static hashval_t
1669 hash_probe_and_action (const void *p)
1670 {
1671  const struct probe_and_action *pa = p;
1672 
1673  return (hashval_t) pa->address;
1674 }
1675 
1676 /* Returns non-zero if the probe_and_actions referenced by p1 and p2
1677  are equal. */
1678 
1679 static int
1680 equal_probe_and_action (const void *p1, const void *p2)
1681 {
1682  const struct probe_and_action *pa1 = p1;
1683  const struct probe_and_action *pa2 = p2;
1684 
1685  return pa1->address == pa2->address;
1686 }
1687 
1688 /* Register a solib event probe and its associated action in the
1689  probes table. */
1690 
1691 static void
1693  enum probe_action action)
1694 {
1695  struct svr4_info *info = get_svr4_info ();
1696  struct probe_and_action lookup, *pa;
1697  void **slot;
1698 
1699  /* Create the probes table, if necessary. */
1700  if (info->probes_table == NULL)
1701  info->probes_table = htab_create_alloc (1, hash_probe_and_action,
1703  xfree, xcalloc, xfree);
1704 
1705  lookup.probe = probe;
1706  lookup.address = address;
1707  slot = htab_find_slot (info->probes_table, &lookup, INSERT);
1708  gdb_assert (*slot == HTAB_EMPTY_ENTRY);
1709 
1710  pa = XCNEW (struct probe_and_action);
1711  pa->probe = probe;
1712  pa->address = address;
1713  pa->action = action;
1714 
1715  *slot = pa;
1716 }
1717 
1718 /* Get the solib event probe at the specified location, and the
1719  action associated with it. Returns NULL if no solib event probe
1720  was found. */
1721 
1722 static struct probe_and_action *
1724 {
1725  struct probe_and_action lookup;
1726  void **slot;
1727 
1728  lookup.address = address;
1729  slot = htab_find_slot (info->probes_table, &lookup, NO_INSERT);
1730 
1731  if (slot == NULL)
1732  return NULL;
1733 
1734  return (struct probe_and_action *) *slot;
1735 }
1736 
1737 /* Decide what action to take when the specified solib event probe is
1738  hit. */
1739 
1740 static enum probe_action
1742 {
1743  enum probe_action action;
1744  unsigned probe_argc;
1745  struct frame_info *frame = get_current_frame ();
1746 
1747  action = pa->action;
1748  if (action == DO_NOTHING || action == PROBES_INTERFACE_FAILED)
1749  return action;
1750 
1751  gdb_assert (action == FULL_RELOAD || action == UPDATE_OR_RELOAD);
1752 
1753  /* Check that an appropriate number of arguments has been supplied.
1754  We expect:
1755  arg0: Lmid_t lmid (mandatory)
1756  arg1: struct r_debug *debug_base (mandatory)
1757  arg2: struct link_map *new (optional, for incremental updates) */
1758  probe_argc = get_probe_argument_count (pa->probe, frame);
1759  if (probe_argc == 2)
1760  action = FULL_RELOAD;
1761  else if (probe_argc < 2)
1762  action = PROBES_INTERFACE_FAILED;
1763 
1764  return action;
1765 }
1766 
1767 /* Populate the shared object list by reading the entire list of
1768  shared objects from the inferior. Handle special cases relating
1769  to the first elements of the list. Returns nonzero on success. */
1770 
1771 static int
1773 {
1774  free_solib_list (info);
1775  info->solib_list = svr4_current_sos_direct (info);
1776 
1777  return 1;
1778 }
1779 
1780 /* Update the shared object list starting from the link-map entry
1781  passed by the linker in the probe's third argument. Returns
1782  nonzero if the list was successfully updated, or zero to indicate
1783  failure. */
1784 
1785 static int
1787 {
1788  struct so_list *tail;
1789  CORE_ADDR prev_lm;
1790 
1791  /* svr4_current_sos_direct contains logic to handle a number of
1792  special cases relating to the first elements of the list. To
1793  avoid duplicating this logic we defer to solist_update_full
1794  if the list is empty. */
1795  if (info->solib_list == NULL)
1796  return 0;
1797 
1798  /* Fall back to a full update if we are using a remote target
1799  that does not support incremental transfers. */
1801  return 0;
1802 
1803  /* Walk to the end of the list. */
1804  for (tail = info->solib_list; tail->next != NULL; tail = tail->next)
1805  /* Nothing. */;
1806  prev_lm = tail->lm_info->lm_addr;
1807 
1808  /* Read the new objects. */
1809  if (info->using_xfer)
1810  {
1811  struct svr4_library_list library_list;
1812  char annex[64];
1813 
1814  xsnprintf (annex, sizeof (annex), "start=%s;prev=%s",
1815  phex_nz (lm, sizeof (lm)),
1816  phex_nz (prev_lm, sizeof (prev_lm)));
1817  if (!svr4_current_sos_via_xfer_libraries (&library_list, annex))
1818  return 0;
1819 
1820  tail->next = library_list.head;
1821  }
1822  else
1823  {
1824  struct so_list **link = &tail->next;
1825 
1826  /* IGNORE_FIRST may safely be set to zero here because the
1827  above check and deferral to solist_update_full ensures
1828  that this call to svr4_read_so_list will never see the
1829  first element. */
1830  if (!svr4_read_so_list (lm, prev_lm, &link, 0))
1831  return 0;
1832  }
1833 
1834  return 1;
1835 }
1836 
1837 /* Disable the probes-based linker interface and revert to the
1838  original interface. We don't reset the breakpoints as the
1839  ones set up for the probes-based interface are adequate. */
1840 
1841 static void
1843 {
1844  struct svr4_info *info = get_svr4_info ();
1845 
1846  warning (_("Probes-based dynamic linker interface failed.\n"
1847  "Reverting to original interface.\n"));
1848 
1849  free_probes_table (info);
1850  free_solib_list (info);
1851 }
1852 
1853 /* Update the solib list as appropriate when using the
1854  probes-based linker interface. Do nothing if using the
1855  standard interface. */
1856 
1857 static void
1859 {
1860  struct svr4_info *info = get_svr4_info ();
1861  struct probe_and_action *pa;
1862  enum probe_action action;
1863  struct cleanup *old_chain, *usm_chain;
1864  struct value *val;
1865  CORE_ADDR pc, debug_base, lm = 0;
1866  int is_initial_ns;
1867  struct frame_info *frame = get_current_frame ();
1868 
1869  /* Do nothing if not using the probes interface. */
1870  if (info->probes_table == NULL)
1871  return;
1872 
1873  /* If anything goes wrong we revert to the original linker
1874  interface. */
1875  old_chain = make_cleanup (disable_probes_interface_cleanup, NULL);
1876 
1878  pa = solib_event_probe_at (info, pc);
1879  if (pa == NULL)
1880  {
1881  do_cleanups (old_chain);
1882  return;
1883  }
1884 
1885  action = solib_event_probe_action (pa);
1886  if (action == PROBES_INTERFACE_FAILED)
1887  {
1888  do_cleanups (old_chain);
1889  return;
1890  }
1891 
1892  if (action == DO_NOTHING)
1893  {
1894  discard_cleanups (old_chain);
1895  return;
1896  }
1897 
1898  /* evaluate_probe_argument looks up symbols in the dynamic linker
1899  using find_pc_section. find_pc_section is accelerated by a cache
1900  called the section map. The section map is invalidated every
1901  time a shared library is loaded or unloaded, and if the inferior
1902  is generating a lot of shared library events then the section map
1903  will be updated every time svr4_handle_solib_event is called.
1904  We called find_pc_section in svr4_create_solib_event_breakpoints,
1905  so we can guarantee that the dynamic linker's sections are in the
1906  section map. We can therefore inhibit section map updates across
1907  these calls to evaluate_probe_argument and save a lot of time. */
1911 
1912  val = evaluate_probe_argument (pa->probe, 1, frame);
1913  if (val == NULL)
1914  {
1915  do_cleanups (old_chain);
1916  return;
1917  }
1918 
1919  debug_base = value_as_address (val);
1920  if (debug_base == 0)
1921  {
1922  do_cleanups (old_chain);
1923  return;
1924  }
1925 
1926  /* Always locate the debug struct, in case it moved. */
1927  info->debug_base = 0;
1928  if (locate_base (info) == 0)
1929  {
1930  do_cleanups (old_chain);
1931  return;
1932  }
1933 
1934  /* GDB does not currently support libraries loaded via dlmopen
1935  into namespaces other than the initial one. We must ignore
1936  any namespace other than the initial namespace here until
1937  support for this is added to GDB. */
1938  if (debug_base != info->debug_base)
1939  action = DO_NOTHING;
1940 
1941  if (action == UPDATE_OR_RELOAD)
1942  {
1943  val = evaluate_probe_argument (pa->probe, 2, frame);
1944  if (val != NULL)
1945  lm = value_as_address (val);
1946 
1947  if (lm == 0)
1948  action = FULL_RELOAD;
1949  }
1950 
1951  /* Resume section map updates. */
1952  do_cleanups (usm_chain);
1953 
1954  if (action == UPDATE_OR_RELOAD)
1955  {
1956  if (!solist_update_incremental (info, lm))
1957  action = FULL_RELOAD;
1958  }
1959 
1960  if (action == FULL_RELOAD)
1961  {
1962  if (!solist_update_full (info))
1963  {
1964  do_cleanups (old_chain);
1965  return;
1966  }
1967  }
1968 
1969  discard_cleanups (old_chain);
1970 }
1971 
1972 /* Helper function for svr4_update_solib_event_breakpoints. */
1973 
1974 static int
1976 {
1977  struct bp_location *loc;
1978 
1979  if (b->type != bp_shlib_event)
1980  {
1981  /* Continue iterating. */
1982  return 0;
1983  }
1984 
1985  for (loc = b->loc; loc != NULL; loc = loc->next)
1986  {
1987  struct svr4_info *info;
1988  struct probe_and_action *pa;
1989 
1990  info = program_space_data (loc->pspace, solib_svr4_pspace_data);
1991  if (info == NULL || info->probes_table == NULL)
1992  continue;
1993 
1994  pa = solib_event_probe_at (info, loc->address);
1995  if (pa == NULL)
1996  continue;
1997 
1998  if (pa->action == DO_NOTHING)
1999  {
2001  enable_breakpoint (b);
2002  else if (b->enable_state == bp_enabled && !stop_on_solib_events)
2003  disable_breakpoint (b);
2004  }
2005 
2006  break;
2007  }
2008 
2009  /* Continue iterating. */
2010  return 0;
2011 }
2012 
2013 /* Enable or disable optional solib event breakpoints as appropriate.
2014  Called whenever stop_on_solib_events is changed. */
2015 
2016 static void
2018 {
2020 }
2021 
2022 /* Create and register solib event breakpoints. PROBES is an array
2023  of NUM_PROBES elements, each of which is vector of probes. A
2024  solib event breakpoint will be created and registered for each
2025  probe. */
2026 
2027 static void
2028 svr4_create_probe_breakpoints (struct gdbarch *gdbarch,
2029  VEC (probe_p) **probes,
2030  struct objfile *objfile)
2031 {
2032  int i;
2033 
2034  for (i = 0; i < NUM_PROBES; i++)
2035  {
2036  enum probe_action action = probe_info[i].action;
2037  struct probe *probe;
2038  int ix;
2039 
2040  for (ix = 0;
2041  VEC_iterate (probe_p, probes[i], ix, probe);
2042  ++ix)
2043  {
2044  CORE_ADDR address = get_probe_address (probe, objfile);
2045 
2046  create_solib_event_breakpoint (gdbarch, address);
2047  register_solib_event_probe (probe, address, action);
2048  }
2049  }
2050 
2052 }
2053 
2054 /* Both the SunOS and the SVR4 dynamic linkers call a marker function
2055  before and after mapping and unmapping shared libraries. The sole
2056  purpose of this method is to allow debuggers to set a breakpoint so
2057  they can track these changes.
2058 
2059  Some versions of the glibc dynamic linker contain named probes
2060  to allow more fine grained stopping. Given the address of the
2061  original marker function, this function attempts to find these
2062  probes, and if found, sets breakpoints on those instead. If the
2063  probes aren't found, a single breakpoint is set on the original
2064  marker function. */
2065 
2066 static void
2067 svr4_create_solib_event_breakpoints (struct gdbarch *gdbarch,
2069 {
2070  struct obj_section *os;
2071 
2072  os = find_pc_section (address);
2073  if (os != NULL)
2074  {
2075  int with_prefix;
2076 
2077  for (with_prefix = 0; with_prefix <= 1; with_prefix++)
2078  {
2079  VEC (probe_p) *probes[NUM_PROBES];
2080  int all_probes_found = 1;
2081  int checked_can_use_probe_arguments = 0;
2082  int i;
2083 
2084  memset (probes, 0, sizeof (probes));
2085  for (i = 0; i < NUM_PROBES; i++)
2086  {
2087  const char *name = probe_info[i].name;
2088  struct probe *p;
2089  char buf[32];
2090 
2091  /* Fedora 17 and Red Hat Enterprise Linux 6.2-6.4
2092  shipped with an early version of the probes code in
2093  which the probes' names were prefixed with "rtld_"
2094  and the "map_failed" probe did not exist. The
2095  locations of the probes are otherwise the same, so
2096  we check for probes with prefixed names if probes
2097  with unprefixed names are not present. */
2098  if (with_prefix)
2099  {
2100  xsnprintf (buf, sizeof (buf), "rtld_%s", name);
2101  name = buf;
2102  }
2103 
2104  probes[i] = find_probes_in_objfile (os->objfile, "rtld", name);
2105 
2106  /* The "map_failed" probe did not exist in early
2107  versions of the probes code in which the probes'
2108  names were prefixed with "rtld_". */
2109  if (strcmp (name, "rtld_map_failed") == 0)
2110  continue;
2111 
2112  if (VEC_empty (probe_p, probes[i]))
2113  {
2114  all_probes_found = 0;
2115  break;
2116  }
2117 
2118  /* Ensure probe arguments can be evaluated. */
2119  if (!checked_can_use_probe_arguments)
2120  {
2121  p = VEC_index (probe_p, probes[i], 0);
2123  {
2124  all_probes_found = 0;
2125  break;
2126  }
2127  checked_can_use_probe_arguments = 1;
2128  }
2129  }
2130 
2131  if (all_probes_found)
2132  svr4_create_probe_breakpoints (gdbarch, probes, os->objfile);
2133 
2134  for (i = 0; i < NUM_PROBES; i++)
2135  VEC_free (probe_p, probes[i]);
2136 
2137  if (all_probes_found)
2138  return;
2139  }
2140  }
2141 
2142  create_solib_event_breakpoint (gdbarch, address);
2143 }
2144 
2145 /* Helper function for gdb_bfd_lookup_symbol. */
2146 
2147 static int
2148 cmp_name_and_sec_flags (asymbol *sym, void *data)
2149 {
2150  return (strcmp (sym->name, (const char *) data) == 0
2151  && (sym->section->flags & (SEC_CODE | SEC_DATA)) != 0);
2152 }
2153 /* Arrange for dynamic linker to hit breakpoint.
2154 
2155  Both the SunOS and the SVR4 dynamic linkers have, as part of their
2156  debugger interface, support for arranging for the inferior to hit
2157  a breakpoint after mapping in the shared libraries. This function
2158  enables that breakpoint.
2159 
2160  For SunOS, there is a special flag location (in_debugger) which we
2161  set to 1. When the dynamic linker sees this flag set, it will set
2162  a breakpoint at a location known only to itself, after saving the
2163  original contents of that place and the breakpoint address itself,
2164  in it's own internal structures. When we resume the inferior, it
2165  will eventually take a SIGTRAP when it runs into the breakpoint.
2166  We handle this (in a different place) by restoring the contents of
2167  the breakpointed location (which is only known after it stops),
2168  chasing around to locate the shared libraries that have been
2169  loaded, then resuming.
2170 
2171  For SVR4, the debugger interface structure contains a member (r_brk)
2172  which is statically initialized at the time the shared library is
2173  built, to the offset of a function (_r_debug_state) which is guaran-
2174  teed to be called once before mapping in a library, and again when
2175  the mapping is complete. At the time we are examining this member,
2176  it contains only the unrelocated offset of the function, so we have
2177  to do our own relocation. Later, when the dynamic linker actually
2178  runs, it relocates r_brk to be the actual address of _r_debug_state().
2179 
2180  The debugger interface structure also contains an enumeration which
2181  is set to either RT_ADD or RT_DELETE prior to changing the mapping,
2182  depending upon whether or not the library is being mapped or unmapped,
2183  and then set to RT_CONSISTENT after the library is mapped/unmapped. */
2184 
2185 static int
2186 enable_break (struct svr4_info *info, int from_tty)
2187 {
2188  struct bound_minimal_symbol msymbol;
2189  const char * const *bkpt_namep;
2190  asection *interp_sect;
2191  char *interp_name;
2192  CORE_ADDR sym_addr;
2193 
2194  info->interp_text_sect_low = info->interp_text_sect_high = 0;
2195  info->interp_plt_sect_low = info->interp_plt_sect_high = 0;
2196 
2197  /* If we already have a shared library list in the target, and
2198  r_debug contains r_brk, set the breakpoint there - this should
2199  mean r_brk has already been relocated. Assume the dynamic linker
2200  is the object containing r_brk. */
2201 
2202  solib_add (NULL, from_tty, &current_target, auto_solib_add);
2203  sym_addr = 0;
2204  if (info->debug_base && solib_svr4_r_map (info) != 0)
2205  sym_addr = solib_svr4_r_brk (info);
2206 
2207  if (sym_addr != 0)
2208  {
2209  struct obj_section *os;
2210 
2211  sym_addr = gdbarch_addr_bits_remove
2213  sym_addr,
2214  &current_target));
2215 
2216  /* On at least some versions of Solaris there's a dynamic relocation
2217  on _r_debug.r_brk and SYM_ADDR may not be relocated yet, e.g., if
2218  we get control before the dynamic linker has self-relocated.
2219  Check if SYM_ADDR is in a known section, if it is assume we can
2220  trust its value. This is just a heuristic though, it could go away
2221  or be replaced if it's getting in the way.
2222 
2223  On ARM we need to know whether the ISA of rtld_db_dlactivity (or
2224  however it's spelled in your particular system) is ARM or Thumb.
2225  That knowledge is encoded in the address, if it's Thumb the low bit
2226  is 1. However, we've stripped that info above and it's not clear
2227  what all the consequences are of passing a non-addr_bits_remove'd
2228  address to svr4_create_solib_event_breakpoints. The call to
2229  find_pc_section verifies we know about the address and have some
2230  hope of computing the right kind of breakpoint to use (via
2231  symbol info). It does mean that GDB needs to be pointed at a
2232  non-stripped version of the dynamic linker in order to obtain
2233  information it already knows about. Sigh. */
2234 
2235  os = find_pc_section (sym_addr);
2236  if (os != NULL)
2237  {
2238  /* Record the relocated start and end address of the dynamic linker
2239  text and plt section for svr4_in_dynsym_resolve_code. */
2240  bfd *tmp_bfd;
2241  CORE_ADDR load_addr;
2242 
2243  tmp_bfd = os->objfile->obfd;
2244  load_addr = ANOFFSET (os->objfile->section_offsets,
2245  SECT_OFF_TEXT (os->objfile));
2246 
2247  interp_sect = bfd_get_section_by_name (tmp_bfd, ".text");
2248  if (interp_sect)
2249  {
2250  info->interp_text_sect_low =
2251  bfd_section_vma (tmp_bfd, interp_sect) + load_addr;
2252  info->interp_text_sect_high =
2253  info->interp_text_sect_low
2254  + bfd_section_size (tmp_bfd, interp_sect);
2255  }
2256  interp_sect = bfd_get_section_by_name (tmp_bfd, ".plt");
2257  if (interp_sect)
2258  {
2259  info->interp_plt_sect_low =
2260  bfd_section_vma (tmp_bfd, interp_sect) + load_addr;
2261  info->interp_plt_sect_high =
2262  info->interp_plt_sect_low
2263  + bfd_section_size (tmp_bfd, interp_sect);
2264  }
2265 
2267  return 1;
2268  }
2269  }
2270 
2271  /* Find the program interpreter; if not found, warn the user and drop
2272  into the old breakpoint at symbol code. */
2273  interp_name = find_program_interpreter ();
2274  if (interp_name)
2275  {
2276  CORE_ADDR load_addr = 0;
2277  int load_addr_found = 0;
2278  int loader_found_in_list = 0;
2279  struct so_list *so;
2280  bfd *tmp_bfd = NULL;
2281  struct target_ops *tmp_bfd_target;
2282 
2283  sym_addr = 0;
2284 
2285  /* Now we need to figure out where the dynamic linker was
2286  loaded so that we can load its symbols and place a breakpoint
2287  in the dynamic linker itself.
2288 
2289  This address is stored on the stack. However, I've been unable
2290  to find any magic formula to find it for Solaris (appears to
2291  be trivial on GNU/Linux). Therefore, we have to try an alternate
2292  mechanism to find the dynamic linker's base address. */
2293 
2294  TRY
2295  {
2296  tmp_bfd = solib_bfd_open (interp_name);
2297  }
2298  CATCH (ex, RETURN_MASK_ALL)
2299  {
2300  }
2301  END_CATCH
2302 
2303  if (tmp_bfd == NULL)
2304  goto bkpt_at_symbol;
2305 
2306  /* Now convert the TMP_BFD into a target. That way target, as
2307  well as BFD operations can be used. */
2308  tmp_bfd_target = target_bfd_reopen (tmp_bfd);
2309  /* target_bfd_reopen acquired its own reference, so we can
2310  release ours now. */
2311  gdb_bfd_unref (tmp_bfd);
2312 
2313  /* On a running target, we can get the dynamic linker's base
2314  address from the shared library table. */
2315  so = master_so_list ();
2316  while (so)
2317  {
2318  if (svr4_same_1 (interp_name, so->so_original_name))
2319  {
2320  load_addr_found = 1;
2321  loader_found_in_list = 1;
2322  load_addr = lm_addr_check (so, tmp_bfd);
2323  break;
2324  }
2325  so = so->next;
2326  }
2327 
2328  /* If we were not able to find the base address of the loader
2329  from our so_list, then try using the AT_BASE auxilliary entry. */
2330  if (!load_addr_found)
2331  if (target_auxv_search (&current_target, AT_BASE, &load_addr) > 0)
2332  {
2333  int addr_bit = gdbarch_addr_bit (target_gdbarch ());
2334 
2335  /* Ensure LOAD_ADDR has proper sign in its possible upper bits so
2336  that `+ load_addr' will overflow CORE_ADDR width not creating
2337  invalid addresses like 0x101234567 for 32bit inferiors on 64bit
2338  GDB. */
2339 
2340  if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
2341  {
2342  CORE_ADDR space_size = (CORE_ADDR) 1 << addr_bit;
2343  CORE_ADDR tmp_entry_point = exec_entry_point (tmp_bfd,
2344  tmp_bfd_target);
2345 
2346  gdb_assert (load_addr < space_size);
2347 
2348  /* TMP_ENTRY_POINT exceeding SPACE_SIZE would be for prelinked
2349  64bit ld.so with 32bit executable, it should not happen. */
2350 
2351  if (tmp_entry_point < space_size
2352  && tmp_entry_point + load_addr >= space_size)
2353  load_addr -= space_size;
2354  }
2355 
2356  load_addr_found = 1;
2357  }
2358 
2359  /* Otherwise we find the dynamic linker's base address by examining
2360  the current pc (which should point at the entry point for the
2361  dynamic linker) and subtracting the offset of the entry point.
2362 
2363  This is more fragile than the previous approaches, but is a good
2364  fallback method because it has actually been working well in
2365  most cases. */
2366  if (!load_addr_found)
2367  {
2368  struct regcache *regcache
2370 
2371  load_addr = (regcache_read_pc (regcache)
2372  - exec_entry_point (tmp_bfd, tmp_bfd_target));
2373  }
2374 
2375  if (!loader_found_in_list)
2376  {
2377  info->debug_loader_name = xstrdup (interp_name);
2378  info->debug_loader_offset_p = 1;
2379  info->debug_loader_offset = load_addr;
2380  solib_add (NULL, from_tty, &current_target, auto_solib_add);
2381  }
2382 
2383  /* Record the relocated start and end address of the dynamic linker
2384  text and plt section for svr4_in_dynsym_resolve_code. */
2385  interp_sect = bfd_get_section_by_name (tmp_bfd, ".text");
2386  if (interp_sect)
2387  {
2388  info->interp_text_sect_low =
2389  bfd_section_vma (tmp_bfd, interp_sect) + load_addr;
2390  info->interp_text_sect_high =
2391  info->interp_text_sect_low
2392  + bfd_section_size (tmp_bfd, interp_sect);
2393  }
2394  interp_sect = bfd_get_section_by_name (tmp_bfd, ".plt");
2395  if (interp_sect)
2396  {
2397  info->interp_plt_sect_low =
2398  bfd_section_vma (tmp_bfd, interp_sect) + load_addr;
2399  info->interp_plt_sect_high =
2400  info->interp_plt_sect_low
2401  + bfd_section_size (tmp_bfd, interp_sect);
2402  }
2403 
2404  /* Now try to set a breakpoint in the dynamic linker. */
2405  for (bkpt_namep = solib_break_names; *bkpt_namep != NULL; bkpt_namep++)
2406  {
2407  sym_addr = gdb_bfd_lookup_symbol (tmp_bfd, cmp_name_and_sec_flags,
2408  (void *) *bkpt_namep);
2409  if (sym_addr != 0)
2410  break;
2411  }
2412 
2413  if (sym_addr != 0)
2414  /* Convert 'sym_addr' from a function pointer to an address.
2415  Because we pass tmp_bfd_target instead of the current
2416  target, this will always produce an unrelocated value. */
2418  sym_addr,
2419  tmp_bfd_target);
2420 
2421  /* We're done with both the temporary bfd and target. Closing
2422  the target closes the underlying bfd, because it holds the
2423  only remaining reference. */
2424  target_close (tmp_bfd_target);
2425 
2426  if (sym_addr != 0)
2427  {
2429  load_addr + sym_addr);
2430  xfree (interp_name);
2431  return 1;
2432  }
2433 
2434  /* For whatever reason we couldn't set a breakpoint in the dynamic
2435  linker. Warn and drop into the old code. */
2436  bkpt_at_symbol:
2437  xfree (interp_name);
2438  warning (_("Unable to find dynamic linker breakpoint function.\n"
2439  "GDB will be unable to debug shared library initializers\n"
2440  "and track explicitly loaded dynamic code."));
2441  }
2442 
2443  /* Scan through the lists of symbols, trying to look up the symbol and
2444  set a breakpoint there. Terminate loop when we/if we succeed. */
2445 
2446  for (bkpt_namep = solib_break_names; *bkpt_namep != NULL; bkpt_namep++)
2447  {
2448  msymbol = lookup_minimal_symbol (*bkpt_namep, NULL, symfile_objfile);
2449  if ((msymbol.minsym != NULL)
2450  && (BMSYMBOL_VALUE_ADDRESS (msymbol) != 0))
2451  {
2452  sym_addr = BMSYMBOL_VALUE_ADDRESS (msymbol);
2454  sym_addr,
2455  &current_target);
2457  return 1;
2458  }
2459  }
2460 
2461  if (interp_name != NULL && !current_inferior ()->attach_flag)
2462  {
2463  for (bkpt_namep = bkpt_names; *bkpt_namep != NULL; bkpt_namep++)
2464  {
2465  msymbol = lookup_minimal_symbol (*bkpt_namep, NULL, symfile_objfile);
2466  if ((msymbol.minsym != NULL)
2467  && (BMSYMBOL_VALUE_ADDRESS (msymbol) != 0))
2468  {
2469  sym_addr = BMSYMBOL_VALUE_ADDRESS (msymbol);
2471  sym_addr,
2472  &current_target);
2474  return 1;
2475  }
2476  }
2477  }
2478  return 0;
2479 }
2480 
2481 /* Implement the "special_symbol_handling" target_so_ops method. */
2482 
2483 static void
2485 {
2486  /* Nothing to do. */
2487 }
2488 
2489 /* Read the ELF program headers from ABFD. Return the contents and
2490  set *PHDRS_SIZE to the size of the program headers. */
2491 
2492 static gdb_byte *
2493 read_program_headers_from_bfd (bfd *abfd, int *phdrs_size)
2494 {
2495  Elf_Internal_Ehdr *ehdr;
2496  gdb_byte *buf;
2497 
2498  ehdr = elf_elfheader (abfd);
2499 
2500  *phdrs_size = ehdr->e_phnum * ehdr->e_phentsize;
2501  if (*phdrs_size == 0)
2502  return NULL;
2503 
2504  buf = xmalloc (*phdrs_size);
2505  if (bfd_seek (abfd, ehdr->e_phoff, SEEK_SET) != 0
2506  || bfd_bread (buf, *phdrs_size, abfd) != *phdrs_size)
2507  {
2508  xfree (buf);
2509  return NULL;
2510  }
2511 
2512  return buf;
2513 }
2514 
2515 /* Return 1 and fill *DISPLACEMENTP with detected PIE offset of inferior
2516  exec_bfd. Otherwise return 0.
2517 
2518  We relocate all of the sections by the same amount. This
2519  behavior is mandated by recent editions of the System V ABI.
2520  According to the System V Application Binary Interface,
2521  Edition 4.1, page 5-5:
2522 
2523  ... Though the system chooses virtual addresses for
2524  individual processes, it maintains the segments' relative
2525  positions. Because position-independent code uses relative
2526  addressesing between segments, the difference between
2527  virtual addresses in memory must match the difference
2528  between virtual addresses in the file. The difference
2529  between the virtual address of any segment in memory and
2530  the corresponding virtual address in the file is thus a
2531  single constant value for any one executable or shared
2532  object in a given process. This difference is the base
2533  address. One use of the base address is to relocate the
2534  memory image of the program during dynamic linking.
2535 
2536  The same language also appears in Edition 4.0 of the System V
2537  ABI and is left unspecified in some of the earlier editions.
2538 
2539  Decide if the objfile needs to be relocated. As indicated above, we will
2540  only be here when execution is stopped. But during attachment PC can be at
2541  arbitrary address therefore regcache_read_pc can be misleading (contrary to
2542  the auxv AT_ENTRY value). Moreover for executable with interpreter section
2543  regcache_read_pc would point to the interpreter and not the main executable.
2544 
2545  So, to summarize, relocations are necessary when the start address obtained
2546  from the executable is different from the address in auxv AT_ENTRY entry.
2547 
2548  [ The astute reader will note that we also test to make sure that
2549  the executable in question has the DYNAMIC flag set. It is my
2550  opinion that this test is unnecessary (undesirable even). It
2551  was added to avoid inadvertent relocation of an executable
2552  whose e_type member in the ELF header is not ET_DYN. There may
2553  be a time in the future when it is desirable to do relocations
2554  on other types of files as well in which case this condition
2555  should either be removed or modified to accomodate the new file
2556  type. - Kevin, Nov 2000. ] */
2557 
2558 static int
2560 {
2561  /* ENTRY_POINT is a possible function descriptor - before
2562  a call to gdbarch_convert_from_func_ptr_addr. */
2563  CORE_ADDR entry_point, exec_displacement;
2564 
2565  if (exec_bfd == NULL)
2566  return 0;
2567 
2568  /* Therefore for ELF it is ET_EXEC and not ET_DYN. Both shared libraries
2569  being executed themselves and PIE (Position Independent Executable)
2570  executables are ET_DYN. */
2571 
2572  if ((bfd_get_file_flags (exec_bfd) & DYNAMIC) == 0)
2573  return 0;
2574 
2575  if (target_auxv_search (&current_target, AT_ENTRY, &entry_point) <= 0)
2576  return 0;
2577 
2578  exec_displacement = entry_point - bfd_get_start_address (exec_bfd);
2579 
2580  /* Verify the EXEC_DISPLACEMENT candidate complies with the required page
2581  alignment. It is cheaper than the program headers comparison below. */
2582 
2583  if (bfd_get_flavour (exec_bfd) == bfd_target_elf_flavour)
2584  {
2585  const struct elf_backend_data *elf = get_elf_backend_data (exec_bfd);
2586 
2587  /* p_align of PT_LOAD segments does not specify any alignment but
2588  only congruency of addresses:
2589  p_offset % p_align == p_vaddr % p_align
2590  Kernel is free to load the executable with lower alignment. */
2591 
2592  if ((exec_displacement & (elf->minpagesize - 1)) != 0)
2593  return 0;
2594  }
2595 
2596  /* Verify that the auxilliary vector describes the same file as exec_bfd, by
2597  comparing their program headers. If the program headers in the auxilliary
2598  vector do not match the program headers in the executable, then we are
2599  looking at a different file than the one used by the kernel - for
2600  instance, "gdb program" connected to "gdbserver :PORT ld.so program". */
2601 
2602  if (bfd_get_flavour (exec_bfd) == bfd_target_elf_flavour)
2603  {
2604  /* Be optimistic and clear OK only if GDB was able to verify the headers
2605  really do not match. */
2606  int phdrs_size, phdrs2_size, ok = 1;
2607  gdb_byte *buf, *buf2;
2608  int arch_size;
2609 
2610  buf = read_program_header (-1, &phdrs_size, &arch_size);
2611  buf2 = read_program_headers_from_bfd (exec_bfd, &phdrs2_size);
2612  if (buf != NULL && buf2 != NULL)
2613  {
2614  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
2615 
2616  /* We are dealing with three different addresses. EXEC_BFD
2617  represents current address in on-disk file. target memory content
2618  may be different from EXEC_BFD as the file may have been prelinked
2619  to a different address after the executable has been loaded.
2620  Moreover the address of placement in target memory can be
2621  different from what the program headers in target memory say -
2622  this is the goal of PIE.
2623 
2624  Detected DISPLACEMENT covers both the offsets of PIE placement and
2625  possible new prelink performed after start of the program. Here
2626  relocate BUF and BUF2 just by the EXEC_BFD vs. target memory
2627  content offset for the verification purpose. */
2628 
2629  if (phdrs_size != phdrs2_size
2630  || bfd_get_arch_size (exec_bfd) != arch_size)
2631  ok = 0;
2632  else if (arch_size == 32
2633  && phdrs_size >= sizeof (Elf32_External_Phdr)
2634  && phdrs_size % sizeof (Elf32_External_Phdr) == 0)
2635  {
2636  Elf_Internal_Ehdr *ehdr2 = elf_tdata (exec_bfd)->elf_header;
2637  Elf_Internal_Phdr *phdr2 = elf_tdata (exec_bfd)->phdr;
2638  CORE_ADDR displacement = 0;
2639  int i;
2640 
2641  /* DISPLACEMENT could be found more easily by the difference of
2642  ehdr2->e_entry. But we haven't read the ehdr yet, and we
2643  already have enough information to compute that displacement
2644  with what we've read. */
2645 
2646  for (i = 0; i < ehdr2->e_phnum; i++)
2647  if (phdr2[i].p_type == PT_LOAD)
2648  {
2649  Elf32_External_Phdr *phdrp;
2650  gdb_byte *buf_vaddr_p, *buf_paddr_p;
2651  CORE_ADDR vaddr, paddr;
2652  CORE_ADDR displacement_vaddr = 0;
2653  CORE_ADDR displacement_paddr = 0;
2654 
2655  phdrp = &((Elf32_External_Phdr *) buf)[i];
2656  buf_vaddr_p = (gdb_byte *) &phdrp->p_vaddr;
2657  buf_paddr_p = (gdb_byte *) &phdrp->p_paddr;
2658 
2659  vaddr = extract_unsigned_integer (buf_vaddr_p, 4,
2660  byte_order);
2661  displacement_vaddr = vaddr - phdr2[i].p_vaddr;
2662 
2663  paddr = extract_unsigned_integer (buf_paddr_p, 4,
2664  byte_order);
2665  displacement_paddr = paddr - phdr2[i].p_paddr;
2666 
2667  if (displacement_vaddr == displacement_paddr)
2668  displacement = displacement_vaddr;
2669 
2670  break;
2671  }
2672 
2673  /* Now compare BUF and BUF2 with optional DISPLACEMENT. */
2674 
2675  for (i = 0; i < phdrs_size / sizeof (Elf32_External_Phdr); i++)
2676  {
2677  Elf32_External_Phdr *phdrp;
2678  Elf32_External_Phdr *phdr2p;
2679  gdb_byte *buf_vaddr_p, *buf_paddr_p;
2680  CORE_ADDR vaddr, paddr;
2681  asection *plt2_asect;
2682 
2683  phdrp = &((Elf32_External_Phdr *) buf)[i];
2684  buf_vaddr_p = (gdb_byte *) &phdrp->p_vaddr;
2685  buf_paddr_p = (gdb_byte *) &phdrp->p_paddr;
2686  phdr2p = &((Elf32_External_Phdr *) buf2)[i];
2687 
2688  /* PT_GNU_STACK is an exception by being never relocated by
2689  prelink as its addresses are always zero. */
2690 
2691  if (memcmp (phdrp, phdr2p, sizeof (*phdrp)) == 0)
2692  continue;
2693 
2694  /* Check also other adjustment combinations - PR 11786. */
2695 
2696  vaddr = extract_unsigned_integer (buf_vaddr_p, 4,
2697  byte_order);
2698  vaddr -= displacement;
2699  store_unsigned_integer (buf_vaddr_p, 4, byte_order, vaddr);
2700 
2701  paddr = extract_unsigned_integer (buf_paddr_p, 4,
2702  byte_order);
2703  paddr -= displacement;
2704  store_unsigned_integer (buf_paddr_p, 4, byte_order, paddr);
2705 
2706  if (memcmp (phdrp, phdr2p, sizeof (*phdrp)) == 0)
2707  continue;
2708 
2709  /* Strip modifies the flags and alignment of PT_GNU_RELRO.
2710  CentOS-5 has problems with filesz, memsz as well.
2711  See PR 11786. */
2712  if (phdr2[i].p_type == PT_GNU_RELRO)
2713  {
2714  Elf32_External_Phdr tmp_phdr = *phdrp;
2715  Elf32_External_Phdr tmp_phdr2 = *phdr2p;
2716 
2717  memset (tmp_phdr.p_filesz, 0, 4);
2718  memset (tmp_phdr.p_memsz, 0, 4);
2719  memset (tmp_phdr.p_flags, 0, 4);
2720  memset (tmp_phdr.p_align, 0, 4);
2721  memset (tmp_phdr2.p_filesz, 0, 4);
2722  memset (tmp_phdr2.p_memsz, 0, 4);
2723  memset (tmp_phdr2.p_flags, 0, 4);
2724  memset (tmp_phdr2.p_align, 0, 4);
2725 
2726  if (memcmp (&tmp_phdr, &tmp_phdr2, sizeof (tmp_phdr))
2727  == 0)
2728  continue;
2729  }
2730 
2731  /* prelink can convert .plt SHT_NOBITS to SHT_PROGBITS. */
2732  plt2_asect = bfd_get_section_by_name (exec_bfd, ".plt");
2733  if (plt2_asect)
2734  {
2735  int content2;
2736  gdb_byte *buf_filesz_p = (gdb_byte *) &phdrp->p_filesz;
2737  CORE_ADDR filesz;
2738 
2739  content2 = (bfd_get_section_flags (exec_bfd, plt2_asect)
2740  & SEC_HAS_CONTENTS) != 0;
2741 
2742  filesz = extract_unsigned_integer (buf_filesz_p, 4,
2743  byte_order);
2744 
2745  /* PLT2_ASECT is from on-disk file (exec_bfd) while
2746  FILESZ is from the in-memory image. */
2747  if (content2)
2748  filesz += bfd_get_section_size (plt2_asect);
2749  else
2750  filesz -= bfd_get_section_size (plt2_asect);
2751 
2752  store_unsigned_integer (buf_filesz_p, 4, byte_order,
2753  filesz);
2754 
2755  if (memcmp (phdrp, phdr2p, sizeof (*phdrp)) == 0)
2756  continue;
2757  }
2758 
2759  ok = 0;
2760  break;
2761  }
2762  }
2763  else if (arch_size == 64
2764  && phdrs_size >= sizeof (Elf64_External_Phdr)
2765  && phdrs_size % sizeof (Elf64_External_Phdr) == 0)
2766  {
2767  Elf_Internal_Ehdr *ehdr2 = elf_tdata (exec_bfd)->elf_header;
2768  Elf_Internal_Phdr *phdr2 = elf_tdata (exec_bfd)->phdr;
2769  CORE_ADDR displacement = 0;
2770  int i;
2771 
2772  /* DISPLACEMENT could be found more easily by the difference of
2773  ehdr2->e_entry. But we haven't read the ehdr yet, and we
2774  already have enough information to compute that displacement
2775  with what we've read. */
2776 
2777  for (i = 0; i < ehdr2->e_phnum; i++)
2778  if (phdr2[i].p_type == PT_LOAD)
2779  {
2780  Elf64_External_Phdr *phdrp;
2781  gdb_byte *buf_vaddr_p, *buf_paddr_p;
2782  CORE_ADDR vaddr, paddr;
2783  CORE_ADDR displacement_vaddr = 0;
2784  CORE_ADDR displacement_paddr = 0;
2785 
2786  phdrp = &((Elf64_External_Phdr *) buf)[i];
2787  buf_vaddr_p = (gdb_byte *) &phdrp->p_vaddr;
2788  buf_paddr_p = (gdb_byte *) &phdrp->p_paddr;
2789 
2790  vaddr = extract_unsigned_integer (buf_vaddr_p, 8,
2791  byte_order);
2792  displacement_vaddr = vaddr - phdr2[i].p_vaddr;
2793 
2794  paddr = extract_unsigned_integer (buf_paddr_p, 8,
2795  byte_order);
2796  displacement_paddr = paddr - phdr2[i].p_paddr;
2797 
2798  if (displacement_vaddr == displacement_paddr)
2799  displacement = displacement_vaddr;
2800 
2801  break;
2802  }
2803 
2804  /* Now compare BUF and BUF2 with optional DISPLACEMENT. */
2805 
2806  for (i = 0; i < phdrs_size / sizeof (Elf64_External_Phdr); i++)
2807  {
2808  Elf64_External_Phdr *phdrp;
2809  Elf64_External_Phdr *phdr2p;
2810  gdb_byte *buf_vaddr_p, *buf_paddr_p;
2811  CORE_ADDR vaddr, paddr;
2812  asection *plt2_asect;
2813 
2814  phdrp = &((Elf64_External_Phdr *) buf)[i];
2815  buf_vaddr_p = (gdb_byte *) &phdrp->p_vaddr;
2816  buf_paddr_p = (gdb_byte *) &phdrp->p_paddr;
2817  phdr2p = &((Elf64_External_Phdr *) buf2)[i];
2818 
2819  /* PT_GNU_STACK is an exception by being never relocated by
2820  prelink as its addresses are always zero. */
2821 
2822  if (memcmp (phdrp, phdr2p, sizeof (*phdrp)) == 0)
2823  continue;
2824 
2825  /* Check also other adjustment combinations - PR 11786. */
2826 
2827  vaddr = extract_unsigned_integer (buf_vaddr_p, 8,
2828  byte_order);
2829  vaddr -= displacement;
2830  store_unsigned_integer (buf_vaddr_p, 8, byte_order, vaddr);
2831 
2832  paddr = extract_unsigned_integer (buf_paddr_p, 8,
2833  byte_order);
2834  paddr -= displacement;
2835  store_unsigned_integer (buf_paddr_p, 8, byte_order, paddr);
2836 
2837  if (memcmp (phdrp, phdr2p, sizeof (*phdrp)) == 0)
2838  continue;
2839 
2840  /* Strip modifies the flags and alignment of PT_GNU_RELRO.
2841  CentOS-5 has problems with filesz, memsz as well.
2842  See PR 11786. */
2843  if (phdr2[i].p_type == PT_GNU_RELRO)
2844  {
2845  Elf64_External_Phdr tmp_phdr = *phdrp;
2846  Elf64_External_Phdr tmp_phdr2 = *phdr2p;
2847 
2848  memset (tmp_phdr.p_filesz, 0, 8);
2849  memset (tmp_phdr.p_memsz, 0, 8);
2850  memset (tmp_phdr.p_flags, 0, 4);
2851  memset (tmp_phdr.p_align, 0, 8);
2852  memset (tmp_phdr2.p_filesz, 0, 8);
2853  memset (tmp_phdr2.p_memsz, 0, 8);
2854  memset (tmp_phdr2.p_flags, 0, 4);
2855  memset (tmp_phdr2.p_align, 0, 8);
2856 
2857  if (memcmp (&tmp_phdr, &tmp_phdr2, sizeof (tmp_phdr))
2858  == 0)
2859  continue;
2860  }
2861 
2862  /* prelink can convert .plt SHT_NOBITS to SHT_PROGBITS. */
2863  plt2_asect = bfd_get_section_by_name (exec_bfd, ".plt");
2864  if (plt2_asect)
2865  {
2866  int content2;
2867  gdb_byte *buf_filesz_p = (gdb_byte *) &phdrp->p_filesz;
2868  CORE_ADDR filesz;
2869 
2870  content2 = (bfd_get_section_flags (exec_bfd, plt2_asect)
2871  & SEC_HAS_CONTENTS) != 0;
2872 
2873  filesz = extract_unsigned_integer (buf_filesz_p, 8,
2874  byte_order);
2875 
2876  /* PLT2_ASECT is from on-disk file (exec_bfd) while
2877  FILESZ is from the in-memory image. */
2878  if (content2)
2879  filesz += bfd_get_section_size (plt2_asect);
2880  else
2881  filesz -= bfd_get_section_size (plt2_asect);
2882 
2883  store_unsigned_integer (buf_filesz_p, 8, byte_order,
2884  filesz);
2885 
2886  if (memcmp (phdrp, phdr2p, sizeof (*phdrp)) == 0)
2887  continue;
2888  }
2889 
2890  ok = 0;
2891  break;
2892  }
2893  }
2894  else
2895  ok = 0;
2896  }
2897 
2898  xfree (buf);
2899  xfree (buf2);
2900 
2901  if (!ok)
2902  return 0;
2903  }
2904 
2905  if (info_verbose)
2906  {
2907  /* It can be printed repeatedly as there is no easy way to check
2908  the executable symbols/file has been already relocated to
2909  displacement. */
2910 
2911  printf_unfiltered (_("Using PIE (Position Independent Executable) "
2912  "displacement %s for \"%s\".\n"),
2913  paddress (target_gdbarch (), exec_displacement),
2914  bfd_get_filename (exec_bfd));
2915  }
2916 
2917  *displacementp = exec_displacement;
2918  return 1;
2919 }
2920 
2921 /* Relocate the main executable. This function should be called upon
2922  stopping the inferior process at the entry point to the program.
2923  The entry point from BFD is compared to the AT_ENTRY of AUXV and if they are
2924  different, the main executable is relocated by the proper amount. */
2925 
2926 static void
2928 {
2929  CORE_ADDR displacement;
2930 
2931  /* If we are re-running this executable, SYMFILE_OBJFILE->SECTION_OFFSETS
2932  probably contains the offsets computed using the PIE displacement
2933  from the previous run, which of course are irrelevant for this run.
2934  So we need to determine the new PIE displacement and recompute the
2935  section offsets accordingly, even if SYMFILE_OBJFILE->SECTION_OFFSETS
2936  already contains pre-computed offsets.
2937 
2938  If we cannot compute the PIE displacement, either:
2939 
2940  - The executable is not PIE.
2941 
2942  - SYMFILE_OBJFILE does not match the executable started in the target.
2943  This can happen for main executable symbols loaded at the host while
2944  `ld.so --ld-args main-executable' is loaded in the target.
2945 
2946  Then we leave the section offsets untouched and use them as is for
2947  this run. Either:
2948 
2949  - These section offsets were properly reset earlier, and thus
2950  already contain the correct values. This can happen for instance
2951  when reconnecting via the remote protocol to a target that supports
2952  the `qOffsets' packet.
2953 
2954  - The section offsets were not reset earlier, and the best we can
2955  hope is that the old offsets are still applicable to the new run. */
2956 
2957  if (! svr4_exec_displacement (&displacement))
2958  return;
2959 
2960  /* Even DISPLACEMENT 0 is a valid new difference of in-memory vs. in-file
2961  addresses. */
2962 
2963  if (symfile_objfile)
2964  {
2965  struct section_offsets *new_offsets;
2966  int i;
2967 
2968  new_offsets = alloca (symfile_objfile->num_sections
2969  * sizeof (*new_offsets));
2970 
2971  for (i = 0; i < symfile_objfile->num_sections; i++)
2972  new_offsets->offsets[i] = displacement;
2973 
2974  objfile_relocate (symfile_objfile, new_offsets);
2975  }
2976  else if (exec_bfd)
2977  {
2978  asection *asect;
2979 
2980  for (asect = exec_bfd->sections; asect != NULL; asect = asect->next)
2981  exec_set_section_address (bfd_get_filename (exec_bfd), asect->index,
2982  (bfd_section_vma (exec_bfd, asect)
2983  + displacement));
2984  }
2985 }
2986 
2987 /* Implement the "create_inferior_hook" target_solib_ops method.
2988 
2989  For SVR4 executables, this first instruction is either the first
2990  instruction in the dynamic linker (for dynamically linked
2991  executables) or the instruction at "start" for statically linked
2992  executables. For dynamically linked executables, the system
2993  first exec's /lib/libc.so.N, which contains the dynamic linker,
2994  and starts it running. The dynamic linker maps in any needed
2995  shared libraries, maps in the actual user executable, and then
2996  jumps to "start" in the user executable.
2997 
2998  We can arrange to cooperate with the dynamic linker to discover the
2999  names of shared libraries that are dynamically linked, and the base
3000  addresses to which they are linked.
3001 
3002  This function is responsible for discovering those names and
3003  addresses, and saving sufficient information about them to allow
3004  their symbols to be read at a later time. */
3005 
3006 static void
3008 {
3009  struct svr4_info *info;
3010 
3011  info = get_svr4_info ();
3012 
3013  /* Clear the probes-based interface's state. */
3014  free_probes_table (info);
3015  free_solib_list (info);
3016 
3017  /* Relocate the main executable if necessary. */
3019 
3020  /* No point setting a breakpoint in the dynamic linker if we can't
3021  hit it (e.g., a core file, or a trace file). */
3022  if (!target_has_execution)
3023  return;
3024 
3026  return;
3027 
3028  if (!enable_break (info, from_tty))
3029  return;
3030 }
3031 
3032 static void
3034 {
3035  struct svr4_info *info;
3036 
3037  info = get_svr4_info ();
3038  info->debug_base = 0;
3039  info->debug_loader_offset_p = 0;
3040  info->debug_loader_offset = 0;
3041  xfree (info->debug_loader_name);
3042  info->debug_loader_name = NULL;
3043 }
3044 
3045 /* Clear any bits of ADDR that wouldn't fit in a target-format
3046  data pointer. "Data pointer" here refers to whatever sort of
3047  address the dynamic linker uses to manage its sections. At the
3048  moment, we don't support shared libraries on any processors where
3049  code and data pointers are different sizes.
3050 
3051  This isn't really the right solution. What we really need here is
3052  a way to do arithmetic on CORE_ADDR values that respects the
3053  natural pointer/address correspondence. (For example, on the MIPS,
3054  converting a 32-bit pointer to a 64-bit CORE_ADDR requires you to
3055  sign-extend the value. There, simply truncating the bits above
3056  gdbarch_ptr_bit, as we do below, is no good.) This should probably
3057  be a new gdbarch method or something. */
3058 static CORE_ADDR
3060 {
3061  if (gdbarch_ptr_bit (target_gdbarch ()) == sizeof (CORE_ADDR) * 8)
3062  /* We don't need to truncate anything, and the bit twiddling below
3063  will fail due to overflow problems. */
3064  return addr;
3065  else
3066  return addr & (((CORE_ADDR) 1 << gdbarch_ptr_bit (target_gdbarch ())) - 1);
3067 }
3068 
3069 
3070 static void
3072  struct target_section *sec)
3073 {
3074  bfd *abfd = sec->the_bfd_section->owner;
3075 
3076  sec->addr = svr4_truncate_ptr (sec->addr + lm_addr_check (so, abfd));
3077  sec->endaddr = svr4_truncate_ptr (sec->endaddr + lm_addr_check (so, abfd));
3078 }
3079 
3080 
3081 /* Architecture-specific operations. */
3082 
3083 /* Per-architecture data key. */
3085 
3087 {
3088  /* Return a description of the layout of `struct link_map'. */
3089  struct link_map_offsets *(*fetch_link_map_offsets)(void);
3090 };
3091 
3092 /* Return a default for the architecture-specific operations. */
3093 
3094 static void *
3095 solib_svr4_init (struct obstack *obstack)
3096 {
3097  struct solib_svr4_ops *ops;
3098 
3099  ops = OBSTACK_ZALLOC (obstack, struct solib_svr4_ops);
3100  ops->fetch_link_map_offsets = NULL;
3101  return ops;
3102 }
3103 
3104 /* Set the architecture-specific `struct link_map_offsets' fetcher for
3105  GDBARCH to FLMO. Also, install SVR4 solib_ops into GDBARCH. */
3106 
3107 void
3108 set_solib_svr4_fetch_link_map_offsets (struct gdbarch *gdbarch,
3109  struct link_map_offsets *(*flmo) (void))
3110 {
3111  struct solib_svr4_ops *ops = gdbarch_data (gdbarch, solib_svr4_data);
3112 
3113  ops->fetch_link_map_offsets = flmo;
3114 
3115  set_solib_ops (gdbarch, &svr4_so_ops);
3116 }
3117 
3118 /* Fetch a link_map_offsets structure using the architecture-specific
3119  `struct link_map_offsets' fetcher. */
3120 
3121 static struct link_map_offsets *
3123 {
3124  struct solib_svr4_ops *ops = gdbarch_data (target_gdbarch (), solib_svr4_data);
3125 
3127  return ops->fetch_link_map_offsets ();
3128 }
3129 
3130 /* Return 1 if a link map offset fetcher has been defined, 0 otherwise. */
3131 
3132 static int
3134 {
3135  struct solib_svr4_ops *ops = gdbarch_data (target_gdbarch (), solib_svr4_data);
3136 
3137  return (ops->fetch_link_map_offsets != NULL);
3138 }
3139 
3140 
3141 /* Most OS'es that have SVR4-style ELF dynamic libraries define a
3142  `struct r_debug' and a `struct link_map' that are binary compatible
3143  with the origional SVR4 implementation. */
3144 
3145 /* Fetch (and possibly build) an appropriate `struct link_map_offsets'
3146  for an ILP32 SVR4 system. */
3147 
3148 struct link_map_offsets *
3150 {
3151  static struct link_map_offsets lmo;
3152  static struct link_map_offsets *lmp = NULL;
3153 
3154  if (lmp == NULL)
3155  {
3156  lmp = &lmo;
3157 
3158  lmo.r_version_offset = 0;
3159  lmo.r_version_size = 4;
3160  lmo.r_map_offset = 4;
3161  lmo.r_brk_offset = 8;
3162  lmo.r_ldsomap_offset = 20;
3163 
3164  /* Everything we need is in the first 20 bytes. */
3165  lmo.link_map_size = 20;
3166  lmo.l_addr_offset = 0;
3167  lmo.l_name_offset = 4;
3168  lmo.l_ld_offset = 8;
3169  lmo.l_next_offset = 12;
3170  lmo.l_prev_offset = 16;
3171  }
3172 
3173  return lmp;
3174 }
3175 
3176 /* Fetch (and possibly build) an appropriate `struct link_map_offsets'
3177  for an LP64 SVR4 system. */
3178 
3179 struct link_map_offsets *
3181 {
3182  static struct link_map_offsets lmo;
3183  static struct link_map_offsets *lmp = NULL;
3184 
3185  if (lmp == NULL)
3186  {
3187  lmp = &lmo;
3188 
3189  lmo.r_version_offset = 0;
3190  lmo.r_version_size = 4;
3191  lmo.r_map_offset = 8;
3192  lmo.r_brk_offset = 16;
3193  lmo.r_ldsomap_offset = 40;
3194 
3195  /* Everything we need is in the first 40 bytes. */
3196  lmo.link_map_size = 40;
3197  lmo.l_addr_offset = 0;
3198  lmo.l_name_offset = 8;
3199  lmo.l_ld_offset = 16;
3200  lmo.l_next_offset = 24;
3201  lmo.l_prev_offset = 32;
3202  }
3203 
3204  return lmp;
3205 }
3206 
3207 
3209 
3210 /* Lookup global symbol for ELF DSOs linked with -Bsymbolic. Those DSOs have a
3211  different rule for symbol lookup. The lookup begins here in the DSO, not in
3212  the main executable. */
3213 
3214 static struct symbol *
3216  const char *name,
3217  const domain_enum domain)
3218 {
3219  bfd *abfd;
3220 
3221  if (objfile == symfile_objfile)
3222  abfd = exec_bfd;
3223  else
3224  {
3225  /* OBJFILE should have been passed as the non-debug one. */
3226  gdb_assert (objfile->separate_debug_objfile_backlink == NULL);
3227 
3228  abfd = objfile->obfd;
3229  }
3230 
3231  if (abfd == NULL || scan_dyntag (DT_SYMBOLIC, abfd, NULL) != 1)
3232  return NULL;
3233 
3234  return lookup_global_symbol_from_objfile (objfile, name, domain);
3235 }
3236 
3237 extern initialize_file_ftype _initialize_svr4_solib; /* -Wmissing-prototypes */
3238 
3239 void
3241 {
3242  solib_svr4_data = gdbarch_data_register_pre_init (solib_svr4_init);
3243  solib_svr4_pspace_data
3244  = register_program_space_data_with_cleanup (NULL, svr4_pspace_data_cleanup);
3245 
3261 }
struct gdbarch * target_gdbarch(void)
Definition: gdbarch.c:5143
static void svr4_update_solib_event_breakpoints(void)
Definition: solib-svr4.c:2017
static const char *const bkpt_names[]
Definition: solib-svr4.c:95
struct symbol *(* lookup_lib_global_symbol)(struct objfile *objfile, const char *name, const domain_enum domain)
Definition: solist.h:140
ULONGEST extract_unsigned_integer(const gdb_byte *, int, enum bfd_endian)
Definition: findvar.c:84
static int enable_break(struct svr4_info *info, int from_tty)
Definition: solib-svr4.c:2186
struct cleanup * make_cleanup_free_so(struct so_list *so)
Definition: utils.c:422
static int svr4_keep_data_in_core(CORE_ADDR vaddr, unsigned long size)
Definition: solib-svr4.c:944
static void svr4_free_library_list(void *p_list)
Definition: solib-svr4.c:1080
CORE_ADDR extract_typed_address(const gdb_byte *buf, struct type *type)
Definition: findvar.c:169
CORE_ADDR offsets[1]
Definition: symtab.h:907
static struct so_list * svr4_current_sos_1(void)
Definition: solib-svr4.c:1481
#define SECT_OFF_TEXT(objfile)
Definition: objfiles.h:683
bfd * obfd
Definition: objfiles.h:313
static void svr4_solib_create_inferior_hook(int from_tty)
Definition: solib-svr4.c:3007
static struct lm_info * lm_info_read(CORE_ADDR lm_addr)
Definition: solib-svr4.c:193
unsigned int l_addr_p
Definition: solib-svr4.c:66
struct frame_info * get_current_frame(void)
Definition: frame.c:1461
bfd_vma CORE_ADDR
Definition: common-types.h:41
void * value
Definition: xml-support.h:76
static int has_lm_dynamic_from_link_map(void)
Definition: solib-svr4.c:233
struct link_map_offsets * svr4_lp64_fetch_link_map_offsets(void)
Definition: solib-svr4.c:3180
static void library_list_start_library(struct gdb_xml_parser *parser, const struct gdb_xml_element *element, void *user_data, VEC(gdb_xml_value_s)*attributes)
Definition: solib-svr4.c:1129
static struct so_list * svr4_current_sos_direct(struct svr4_info *info)
Definition: solib-svr4.c:1410
void xfree(void *)
Definition: common-utils.c:97
struct objfile * separate_debug_objfile_backlink
Definition: objfiles.h:401
struct so_list * next
Definition: solist.h:36
struct breakpoint * create_solib_event_breakpoint(struct gdbarch *gdbarch, CORE_ADDR address)
Definition: breakpoint.c:7721
int using_xfer
Definition: solib-svr4.c:368
static void svr4_pspace_data_cleanup(struct program_space *pspace, void *arg)
Definition: solib-svr4.c:406
CORE_ADDR main_lm
Definition: solib-svr4.c:1057
void set_solib_ops(struct gdbarch *gdbarch, const struct target_so_ops *new_ops)
Definition: solib.c:76
#define BMSYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:393
static void svr4_clear_solib(void)
Definition: solib-svr4.c:3033
void warning(const char *fmt,...)
Definition: errors.c:26
static void svr4_clear_so(struct so_list *so)
Definition: solib-svr4.c:1071
int query(const char *ctlstr,...)
Definition: utils.c:1364
int svr4_in_dynsym_resolve_code(CORE_ADDR pc)
Definition: solib-svr4.c:1618
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1690
void(* update_breakpoints)(void)
Definition: solist.h:164
CORE_ADDR interp_plt_sect_low
Definition: solib-svr4.c:363
void * gdbarch_data(struct gdbarch *gdbarch, struct gdbarch_data *data)
Definition: gdbarch.c:4845
static const struct program_space_data * solib_svr4_pspace_data
Definition: solib-svr4.c:382
enum domain_enum_tag domain_enum
static CORE_ADDR solib_svr4_r_brk(struct svr4_info *info)
Definition: solib-svr4.c:895
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition: gdbtypes.c:4766
void(* relocate_section_addresses)(struct so_list *so, struct target_section *)
Definition: solist.h:84
CORE_ADDR debug_base
Definition: solib-svr4.c:347
void(* solib_create_inferior_hook)(int from_tty)
Definition: solist.h:101
struct so_list *(* current_sos)(void)
Definition: solist.h:116
int info_verbose
Definition: top.c:1699
void objfile_relocate(struct objfile *objfile, const struct section_offsets *new_offsets)
Definition: objfiles.c:836
static const struct gdb_xml_attribute svr4_library_list_attributes[]
Definition: solib-svr4.c:1196
bfd *(* bfd_open)(char *pathname)
Definition: solist.h:130
static CORE_ADDR exec_entry_point(struct bfd *abfd, struct target_ops *targ)
Definition: solib-svr4.c:1634
CORE_ADDR address
Definition: solib-svr4.c:1660
static int svr4_update_solib_event_breakpoint(struct breakpoint *b, void *arg)
Definition: solib-svr4.c:1975
static CORE_ADDR locate_base(struct svr4_info *info)
Definition: solib-svr4.c:850
static CORE_ADDR solib_svr4_r_ldsomap(struct svr4_info *info)
Definition: solib-svr4.c:908
probe_action
Definition: solib-svr4.c:111
static enum probe_action solib_event_probe_action(struct probe_and_action *pa)
Definition: solib-svr4.c:1741
static void svr4_create_solib_event_breakpoints(struct gdbarch *gdbarch, CORE_ADDR address)
Definition: solib-svr4.c:2067
struct link_map_offsets * svr4_ilp32_fetch_link_map_offsets(void)
Definition: solib-svr4.c:3149
static int svr4_read_so_list(CORE_ADDR lm, CORE_ADDR prev_lm, struct so_list ***link_ptr_ptr, int ignore_first)
Definition: solib-svr4.c:1317
Definition: solist.h:30
int can_evaluate_probe_arguments(struct probe *probe)
Definition: probe.c:809
struct symbol * lookup_global_symbol_from_objfile(struct objfile *main_objfile, const char *name, const domain_enum domain)
Definition: symtab.c:2290
#define VEC(T)
Definition: vec.h:398
struct gdbarch_data * gdbarch_data_register_pre_init(gdbarch_data_pre_init_ftype *pre_init)
Definition: gdbarch.c:4806
#define SO_NAME_MAX_PATH_SIZE
Definition: solist.h:22
initialize_file_ftype _initialize_svr4_solib
static CORE_ADDR lm_addr(struct so_list *so)
Definition: nto-tdep.c:262
#define _(String)
Definition: gdb_locale.h:40
static CORE_ADDR elf_locate_base(void)
Definition: solib-svr4.c:786
void inhibit_section_map_updates(struct program_space *pspace)
Definition: objfiles.c:1411
static int svr4_same(struct so_list *gdb, struct so_list *inferior)
Definition: solib-svr4.c:187
static CORE_ADDR solib_svr4_r_map(struct svr4_info *info)
Definition: solib-svr4.c:872
enum probe_action action
Definition: solib-svr4.c:138
int(* keep_data_in_core)(CORE_ADDR vaddr, unsigned long size)
Definition: solist.h:156
int gdbarch_vsyscall_range(struct gdbarch *gdbarch, struct mem_range *range)
Definition: gdbarch.c:4655
#define END_CATCH
void enable_breakpoint(struct breakpoint *bpt)
Definition: breakpoint.c:14637
struct regcache * get_current_regcache(void)
Definition: regcache.c:541
struct so_list * head
Definition: solib-svr4.c:1053
int(* open_symbol_file_object)(void *from_ttyp)
Definition: solist.h:123
void store_unsigned_integer(gdb_byte *, int, enum bfd_endian, ULONGEST)
Definition: findvar.c:212
struct so_list * solib_list
Definition: solib-svr4.c:378
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2743
static void svr4_special_symbol_handling(void)
Definition: solib-svr4.c:2484
static CORE_ADDR svr4_truncate_ptr(CORE_ADDR addr)
Definition: solib-svr4.c:3059
CORE_ADDR svr4_fetch_objfile_link_map(struct objfile *objfile)
Definition: solib-svr4.c:1573
static void svr4_relocate_section_addresses(struct so_list *so, struct target_section *sec)
Definition: solib-svr4.c:3071
static int solist_update_incremental(struct svr4_info *info, CORE_ADDR lm)
Definition: solib-svr4.c:1786
struct lm_info * lm_info
Definition: solist.h:42
void(* clear_solib)(void)
Definition: solist.h:98
#define TRY
static int equal_probe_and_action(const void *p1, const void *p2)
Definition: solib-svr4.c:1680
struct so_list * master_so_list(void)
Definition: solib.c:659
const char *const name
Definition: aarch64-tdep.c:68
static const char *const main_name_list[]
Definition: solib-svr4.c:103
struct so_list ** tailp
Definition: solib-svr4.c:1053
#define VEC_iterate(T, V, I, P)
Definition: vec.h:165
int(* in_dynsym_resolve_code)(CORE_ADDR pc)
Definition: solist.h:127
struct bp_location * next
Definition: breakpoint.h:307
CORE_ADDR address
Definition: probe.h:202
#define CATCH(EXCEPTION, MASK)
int gdb_xml_parse_quick(const char *name, const char *dtd_name, const struct gdb_xml_element *elements, const char *document, void *user_data)
Definition: xml-support.c:599
struct target_ops current_target
void gdb_bfd_unref(struct bfd *abfd)
Definition: gdb_bfd.c:475
CORE_ADDR gdbarch_addr_bits_remove(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: gdbarch.c:2992
void initialize_file_ftype(void)
Definition: defs.h:281
struct program_space * pspace
Definition: breakpoint.h:404
CORE_ADDR gdb_bfd_lookup_symbol(bfd *abfd, int(*match_sym)(asymbol *, void *), void *data)
Definition: solib.c:1629
static int scan_dyntag_auxv(const int desired_dyntag, CORE_ADDR *ptr)
Definition: solib-svr4.c:718
#define exec_bfd
Definition: exec.h:32
struct breakpoint * iterate_over_breakpoints(int(*callback)(struct breakpoint *, void *), void *data)
Definition: breakpoint.c:15504
void * xzalloc(size_t size)
Definition: common-utils.c:91
static int svr4_same_1(const char *gdb_so_name, const char *inferior_so_name)
Definition: solib-svr4.c:162
struct target_ops * target_bfd_reopen(struct bfd *abfd)
Definition: bfd-target.c:82
static void svr4_relocate_main_executable(void)
Definition: solib-svr4.c:2927
#define current_target_sections
Definition: progspace.h:224
static int solist_update_full(struct svr4_info *info)
Definition: solib-svr4.c:1772
CORE_ADDR gdbarch_convert_from_func_ptr_addr(struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ)
Definition: gdbarch.c:2975
unsigned get_probe_argument_count(struct probe *probe, struct frame_info *frame)
Definition: probe.c:801
int target_auxv_search(struct target_ops *ops, CORE_ADDR match, CORE_ADDR *valp)
Definition: auxv.c:375
void exception_print(struct ui_file *file, struct gdb_exception e)
Definition: exceptions.c:109
CORE_ADDR l_addr
Definition: nto-tdep.c:254
enum probe_action action
Definition: solib-svr4.c:1663
static void disable_probes_interface_cleanup(void *arg)
Definition: solib-svr4.c:1842
char so_original_name[SO_NAME_MAX_PATH_SIZE]
Definition: solist.h:49
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1420
void free_so(struct so_list *so)
Definition: solib.c:646
void solib_add(const char *pattern, int from_tty, struct target_ops *target, int readsyms)
Definition: solib.c:965
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
#define ANOFFSET(secoff, whichone)
Definition: symtab.h:910
static void free_solib_list(struct svr4_info *info)
Definition: solib-svr4.c:399
void(* handle_event)(void)
Definition: solist.h:170
const char version[]
Definition: version.c:2
void set_solib_svr4_fetch_link_map_offsets(struct gdbarch *gdbarch, struct link_map_offsets *(*flmo)(void))
Definition: solib-svr4.c:3108
int debug_loader_offset_p
Definition: solib-svr4.c:350
void disable_breakpoint(struct breakpoint *bpt)
Definition: breakpoint.c:14486
Definition: gdbtypes.h:749
char so_name[SO_NAME_MAX_PATH_SIZE]
Definition: solist.h:52
char * target_read_stralloc(struct target_ops *ops, enum target_object object, const char *annex)
Definition: target.c:1984
void(* clear_so)(struct so_list *so)
Definition: solist.h:94
#define VEC_index(T, V, I)
Definition: vec.h:151
static void svr4_free_so(struct so_list *so)
Definition: solib-svr4.c:1063
#define gdb_assert(expr)
Definition: gdb_assert.h:33
static int svr4_current_sos_via_xfer_libraries(struct svr4_library_list *list, const char *annex)
Definition: solib-svr4.c:1247
int(* same)(struct so_list *gdb, struct so_list *inferior)
Definition: solist.h:149
#define symfile_objfile
Definition: progspace.h:216
static void svr4_handle_solib_event(void)
Definition: solib-svr4.c:1858
void target_close(struct target_ops *targ)
Definition: target.c:3263
CORE_ADDR endaddr
Definition: target.h:2260
int gdbarch_addr_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1707
#define target_has_execution
Definition: target.h:1726
void printf_unfiltered(const char *format,...)
Definition: utils.c:2399
#define target_augmented_libraries_svr4_read()
Definition: target.h:2168
static char * find_program_interpreter(void)
Definition: solib-svr4.c:586
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: corefile.c:244
static void free_probes_table(struct svr4_info *info)
Definition: solib-svr4.c:387
struct obj_section * find_pc_section(CORE_ADDR pc)
Definition: objfiles.c:1337
struct bfd_section * the_bfd_section
Definition: target.h:2262
CORE_ADDR l_prev
Definition: solib-svr4.c:72
static void * solib_svr4_init(struct obstack *obstack)
Definition: solib-svr4.c:3095
void * xmalloc(YYSIZE_T)
static struct probe_and_action * solib_event_probe_at(struct svr4_info *info, CORE_ADDR address)
Definition: solib-svr4.c:1723
Definition: __init__.py:1
Definition: probe.h:185
CORE_ADDR l_next
Definition: solib-svr4.c:72
CORE_ADDR debug_loader_offset
Definition: solib-svr4.c:353
void(* special_symbol_handling)(void)
Definition: solist.h:107
CORE_ADDR addr
Definition: target.h:2259
void symbol_file_add_main(const char *args, int from_tty)
Definition: symfile.c:1309
void gdb_xml_error(struct gdb_xml_parser *parser, const char *format,...)
Definition: xml-support.c:128
#define VEC_empty(T, V)
Definition: vec.h:132
Definition: value.c:172
int stop_on_solib_events
Definition: infrun.c:332
enum bptype type
Definition: breakpoint.h:669
const char * interp_name(struct interp *interp)
Definition: interps.c:273
void exec_set_section_address(const char *filename, int index, CORE_ADDR address)
Definition: exec.c:980
CORE_ADDR get_probe_address(struct probe *probe, struct objfile *objfile)
Definition: probe.c:793
static struct so_list * svr4_default_sos(void)
Definition: solib-svr4.c:1285
bfd_byte gdb_byte
Definition: common-types.h:38
struct target_so_ops svr4_so_ops
Definition: solib-svr4.c:3208
struct gdb_xml_value * xml_find_attribute(VEC(gdb_xml_value_s)*attributes, const char *name)
Definition: xml-support.c:142
void discard_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:213
static int scan_dyntag(const int desired_dyntag, bfd *abfd, CORE_ADDR *ptr)
Definition: solib-svr4.c:618
#define SEEK_SET
Definition: defs.h:87
static struct link_map_offsets * svr4_fetch_link_map_offsets(void)
Definition: solib-svr4.c:3122
static CORE_ADDR interp_plt_sect_high
Definition: solib-frv.c:442
int xsnprintf(char *str, size_t size, const char *format,...)
Definition: common-utils.c:134
CORE_ADDR interp_text_sect_high
Definition: solib-svr4.c:362
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: target.c:1393
struct ui_file * gdb_stderr
Definition: main.c:72
CORE_ADDR regcache_read_pc(struct regcache *regcache)
Definition: regcache.c:1174
ptid_t inferior_ptid
Definition: infcmd.c:124
struct type * builtin_data_ptr
Definition: gdbtypes.h:1533
static int in_plt_section(CORE_ADDR pc)
Definition: objfiles.h:539
struct minimal_symbol * minsym
Definition: minsyms.h:32
static hashval_t hash_probe_and_action(const void *p)
Definition: solib-svr4.c:1669
void(* free_so)(struct so_list *so)
Definition: solist.h:89
char * safe_strerror(int)
static struct so_list * svr4_current_sos(void)
Definition: solib-svr4.c:1497
struct bp_location * loc
Definition: breakpoint.h:678
char * debug_loader_name
Definition: solib-svr4.c:356
struct objfile * objfile
Definition: objfiles.h:124
static struct svr4_info * get_svr4_info(void)
Definition: solib-svr4.c:420
Definition: buffer.h:23
#define VEC_free(T, V)
Definition: vec.h:180
CORE_ADDR l_name
Definition: solib-svr4.c:72
static gdb_byte * read_program_header(int type, int *p_sect_size, int *p_arch_size)
Definition: solib-svr4.c:449
CORE_ADDR lm_addr
Definition: nto-tdep.c:257
static const char *const solib_break_names[]
Definition: solib-svr4.c:83
int address_in_mem_range(CORE_ADDR address, const struct mem_range *r)
Definition: memrange.c:37
CORE_ADDR l_addr_inferior
Definition: solib-svr4.c:65
CORE_ADDR interp_plt_sect_high
Definition: solib-svr4.c:364
CORE_ADDR l_ld
Definition: solib-svr4.c:72
static int cmp_name_and_sec_flags(asymbol *sym, void *data)
Definition: solib-svr4.c:2148
struct inferior * current_inferior(void)
Definition: inferior.c:57
int in_gnu_ifunc_stub(CORE_ADDR pc)
Definition: minsyms.c:818
gdb_xml_attribute_handler gdb_xml_parse_attr_ulongest
struct program_space * current_program_space
Definition: progspace.c:35
static gdb_byte * read_program_headers_from_bfd(bfd *abfd, int *phdrs_size)
Definition: solib-svr4.c:2493
unsigned long long ULONGEST
Definition: common-types.h:53
static int open_symbol_file_object(void *from_ttyp)
Definition: solib-svr4.c:981
static CORE_ADDR lm_addr_check(const struct so_list *so, bfd *abfd)
Definition: solib-svr4.c:241
static const struct gdb_xml_element svr4_library_list_children[]
Definition: solib-svr4.c:1186
int length
Definition: memrange.h:33
Definition: symtab.h:703
struct link_map_offsets *(* fetch_link_map_offsets)(void)
Definition: solib-svr4.c:3089
CORE_ADDR value_as_address(struct value *val)
Definition: value.c:2679
struct value * evaluate_probe_argument(struct probe *probe, unsigned n, struct frame_info *frame)
Definition: probe.c:817
CORE_ADDR address
Definition: breakpoint.h:410
#define OBSTACK_ZALLOC(OBSTACK, TYPE)
Definition: gdb_obstack.h:27
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1237
#define HOST_CHAR_BIT
Definition: host-defs.h:40
static int svr4_have_link_map_offsets(void)
Definition: solib-svr4.c:3133
#define NUM_PROBES
Definition: solib-svr4.c:156
CORE_ADDR main_lm_addr
Definition: solib-svr4.c:359
ULONGEST read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition: corefile.c:321
struct section_offsets * section_offsets
Definition: objfiles.h:362
static CORE_ADDR interp_text_sect_high
Definition: solib-frv.c:440
CORE_ADDR read_memory_typed_address(CORE_ADDR addr, struct type *type)
Definition: corefile.c:378
static const struct gdb_xml_attribute svr4_library_attributes[]
Definition: solib-svr4.c:1177
enum enable_state enable_state
Definition: breakpoint.h:671
struct probe * probe
Definition: solib-svr4.c:1657
struct objfile * objfile
Definition: solist.h:69
static struct so_list * svr4_copy_library_list(struct so_list *src)
Definition: solib-svr4.c:1096
htab_t probes_table
Definition: solib-svr4.c:374
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition: minsyms.c:163
PTR xcalloc(size_t number, size_t size)
Definition: common-utils.c:71
static void svr4_create_probe_breakpoints(struct gdbarch *gdbarch, VEC(probe_p)**probes, struct objfile *objfile)
Definition: solib-svr4.c:2028
int target_read_string(CORE_ADDR memaddr, char **string, int len, int *errnop)
Definition: target.c:915
void resume_section_map_updates_cleanup(void *arg)
Definition: objfiles.c:1427
static void register_solib_event_probe(struct probe *probe, CORE_ADDR address, enum probe_action action)
Definition: solib-svr4.c:1692
static struct gdbarch_data * solib_svr4_data
Definition: solib-svr4.c:3084
static int svr4_parse_libraries(const char *document, struct svr4_library_list *list)
Definition: solib-svr4.c:1217
size_t size
Definition: go32-nat.c:242
static struct symbol * elf_lookup_lib_symbol(struct objfile *objfile, const char *name, const domain_enum domain)
Definition: solib-svr4.c:3215
bfd * solib_bfd_open(char *pathname)
Definition: solib.c:481
int auto_solib_add
Definition: symfile.c:168
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
struct regcache * get_thread_arch_regcache(ptid_t ptid, struct gdbarch *gdbarch)
Definition: regcache.c:508
static int match_main(const char *)
Definition: solib-svr4.c:1601
static int svr4_exec_displacement(CORE_ADDR *displacementp)
Definition: solib-svr4.c:2559
__extension__ enum domain_enum_tag domain
Definition: symtab.h:730
CORE_ADDR interp_text_sect_low
Definition: solib-svr4.c:361
static void svr4_library_list_start_list(struct gdb_xml_parser *parser, const struct gdb_xml_element *element, void *user_data, VEC(gdb_xml_value_s)*attributes)
Definition: solib-svr4.c:1157
const char * name
Definition: solib-svr4.c:135