Automatic date update in version.in
[platform/upstream/binutils.git] / gdb / solib-pa64.c
1 /* Handle PA64 shared libraries for GDB, the GNU Debugger.
2
3    Copyright (C) 2004-2014 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 /* HP in their infinite stupidity choose not to use standard ELF dynamic
21    linker interfaces.  They also choose not to make their ELF dymamic
22    linker interfaces compatible with the SOM dynamic linker.  The
23    net result is we can not use either of the existing somsolib.c or
24    solib.c.  What a crock.
25
26    Even more disgusting.  This file depends on functions provided only
27    in certain PA64 libraries.  Thus this file is supposed to only be
28    used native.  When will HP ever learn that they need to provide the
29    same functionality in all their libraries!  */
30
31 #include "defs.h"
32 #include "symtab.h"
33 #include "bfd.h"
34 #include "symfile.h"
35 #include "objfiles.h"
36 #include "gdbcore.h"
37 #include "target.h"
38 #include "inferior.h"
39 #include "regcache.h"
40 #include "gdb_bfd.h"
41
42 #include "hppa-tdep.h"
43 #include "solist.h"
44 #include "solib.h"
45 #include "solib-pa64.h"
46
47 #undef SOLIB_PA64_DBG
48
49 /* We can build this file only when running natively on 64-bit HP/UX.
50    We check for that by checking for the elf_hp.h header file.  */
51 #if defined(HAVE_ELF_HP_H) && defined(__LP64__)
52
53 /* FIXME: kettenis/20041213: These includes should be eliminated.  */
54 #include <dlfcn.h>
55 #include <elf.h>
56 #include <elf_hp.h>
57
58 struct lm_info {
59   struct load_module_desc desc;
60   CORE_ADDR desc_addr;
61 };
62
63 /* When adding fields, be sure to clear them in _initialize_pa64_solib.  */
64 typedef struct
65   {
66     CORE_ADDR dld_flags_addr;
67     LONGEST dld_flags;
68     struct bfd_section *dyninfo_sect;
69     int have_read_dld_descriptor;
70     int is_valid;
71     CORE_ADDR load_map;
72     CORE_ADDR load_map_addr;
73     struct load_module_desc dld_desc;
74   }
75 dld_cache_t;
76
77 static dld_cache_t dld_cache;
78
79 static int read_dynamic_info (asection *dyninfo_sect,
80                               dld_cache_t *dld_cache_p);
81
82 static void
83 pa64_relocate_section_addresses (struct so_list *so,
84                                  struct target_section *sec)
85 {
86   asection *asec = sec->the_bfd_section;
87   CORE_ADDR load_offset;
88
89   /* Relocate all the sections based on where they got loaded.  */
90
91   load_offset = bfd_section_vma (so->abfd, asec) - asec->filepos;
92
93   if (asec->flags & SEC_CODE)
94     {
95       sec->addr += so->lm_info->desc.text_base - load_offset;
96       sec->endaddr += so->lm_info->desc.text_base - load_offset;
97     }
98   else if (asec->flags & SEC_DATA)
99     {
100       sec->addr += so->lm_info->desc.data_base - load_offset;
101       sec->endaddr += so->lm_info->desc.data_base - load_offset;
102     }
103 }
104
105 static void
106 pa64_free_so (struct so_list *so)
107 {
108   xfree (so->lm_info);
109 }
110
111 static void
112 pa64_clear_solib (void)
113 {
114 }
115
116 /* Wrapper for target_read_memory for dlgetmodinfo.  */
117
118 static void *
119 pa64_target_read_memory (void *buffer, CORE_ADDR ptr, size_t bufsiz, int ident)
120 {
121   if (target_read_memory (ptr, buffer, bufsiz) != 0)
122     return 0;
123   return buffer;
124 }
125
126 /* Read the dynamic linker's internal shared library descriptor.
127
128    This must happen after dld starts running, so we can't do it in
129    read_dynamic_info.  Record the fact that we have loaded the
130    descriptor.  If the library is archive bound or the load map
131    hasn't been setup, then return zero; else return nonzero.  */
132
133 static int
134 read_dld_descriptor (void)
135 {
136   char *dll_path;
137   asection *dyninfo_sect;
138
139   /* If necessary call read_dynamic_info to extract the contents of the
140      .dynamic section from the shared library.  */
141   if (!dld_cache.is_valid) 
142     {
143       if (symfile_objfile == NULL)
144         error (_("No object file symbols."));
145
146       dyninfo_sect = bfd_get_section_by_name (symfile_objfile->obfd, 
147                                               ".dynamic");
148       if (!dyninfo_sect) 
149         {
150           return 0;
151         }
152
153       if (!read_dynamic_info (dyninfo_sect, &dld_cache))
154         error (_("Unable to read in .dynamic section information."));
155     }
156
157   /* Read the load map pointer.  */
158   if (target_read_memory (dld_cache.load_map_addr,
159                           (char *) &dld_cache.load_map,
160                           sizeof (dld_cache.load_map))
161       != 0)
162     {
163       error (_("Error while reading in load map pointer."));
164     }
165
166   if (!dld_cache.load_map)
167     return 0;
168
169   /* Read in the dld load module descriptor.  */
170   if (dlgetmodinfo (-1, 
171                     &dld_cache.dld_desc,
172                     sizeof (dld_cache.dld_desc), 
173                     pa64_target_read_memory, 
174                     0, 
175                     dld_cache.load_map)
176       == 0)
177     {
178       error (_("Error trying to get information about dynamic linker."));
179     }
180
181   /* Indicate that we have loaded the dld descriptor.  */
182   dld_cache.have_read_dld_descriptor = 1;
183
184   return 1;
185 }
186
187
188 /* Read the .dynamic section and extract the information of interest,
189    which is stored in dld_cache.  The routine elf_locate_base in solib.c 
190    was used as a model for this.  */
191
192 static int
193 read_dynamic_info (asection *dyninfo_sect, dld_cache_t *dld_cache_p)
194 {
195   char *buf;
196   char *bufend;
197   CORE_ADDR dyninfo_addr;
198   int dyninfo_sect_size;
199   CORE_ADDR entry_addr;
200
201   /* Read in .dynamic section, silently ignore errors.  */
202   dyninfo_addr = bfd_section_vma (symfile_objfile->obfd, dyninfo_sect);
203   dyninfo_sect_size = bfd_section_size (exec_bfd, dyninfo_sect);
204   buf = alloca (dyninfo_sect_size);
205   if (target_read_memory (dyninfo_addr, buf, dyninfo_sect_size))
206     return 0;
207
208   /* Scan the .dynamic section and record the items of interest. 
209      In particular, DT_HP_DLD_FLAGS.  */
210   for (bufend = buf + dyninfo_sect_size, entry_addr = dyninfo_addr;
211        buf < bufend;
212        buf += sizeof (Elf64_Dyn), entry_addr += sizeof (Elf64_Dyn))
213     {
214       Elf64_Dyn *x_dynp = (Elf64_Dyn*)buf;
215       Elf64_Sxword dyn_tag;
216       CORE_ADDR dyn_ptr;
217
218       dyn_tag = bfd_h_get_64 (symfile_objfile->obfd, 
219                               (bfd_byte*) &x_dynp->d_tag);
220
221       /* We can't use a switch here because dyn_tag is 64 bits and HP's
222          lame comiler does not handle 64bit items in switch statements.  */
223       if (dyn_tag == DT_NULL)
224         break;
225       else if (dyn_tag == DT_HP_DLD_FLAGS)
226         {
227           /* Set dld_flags_addr and dld_flags in *dld_cache_p.  */
228           dld_cache_p->dld_flags_addr = entry_addr + offsetof(Elf64_Dyn, d_un);
229           if (target_read_memory (dld_cache_p->dld_flags_addr,
230                                   (char*) &dld_cache_p->dld_flags, 
231                                   sizeof (dld_cache_p->dld_flags))
232               != 0)
233             {
234               error (_("Error while reading in "
235                        ".dynamic section of the program."));
236             }
237         }
238       else if (dyn_tag == DT_HP_LOAD_MAP)
239         {
240           /* Dld will place the address of the load map at load_map_addr
241              after it starts running.  */
242           if (target_read_memory (entry_addr + offsetof(Elf64_Dyn, 
243                                                         d_un.d_ptr),
244                                   (char*) &dld_cache_p->load_map_addr,
245                                   sizeof (dld_cache_p->load_map_addr))
246               != 0)
247             {
248               error (_("Error while reading in "
249                        ".dynamic section of the program."));
250             }
251         }
252       else 
253         {
254           /* Tag is not of interest.  */
255         }
256     }
257
258   /* Record other information and set is_valid to 1.  */
259   dld_cache_p->dyninfo_sect = dyninfo_sect;
260
261   /* Verify that we read in required info.  These fields are re-set to zero
262      in pa64_solib_restart.  */
263
264   if (dld_cache_p->dld_flags_addr != 0 && dld_cache_p->load_map_addr != 0) 
265     dld_cache_p->is_valid = 1;
266   else 
267     return 0;
268
269   return 1;
270 }
271
272 /* Helper function for gdb_bfd_lookup_symbol_from_symtab.  */
273
274 static int
275 cmp_name (asymbol *sym, void *data)
276 {
277   return (strcmp (sym->name, (const char *) data) == 0);
278 }
279
280 /* This hook gets called just before the first instruction in the
281    inferior process is executed.
282
283    This is our opportunity to set magic flags in the inferior so
284    that GDB can be notified when a shared library is mapped in and
285    to tell the dynamic linker that a private copy of the library is
286    needed (so GDB can set breakpoints in the library).
287
288    We need to set DT_HP_DEBUG_CALLBACK to indicate that we want the
289    dynamic linker to call the breakpoint routine for significant events.
290    We used to set DT_HP_DEBUG_PRIVATE to indicate that shared libraries
291    should be mapped private.  However, this flag can be set using
292    "chatr +dbg enable".  Not setting DT_HP_DEBUG_PRIVATE allows debugging
293    with shared libraries mapped shareable.  */
294
295 static void
296 pa64_solib_create_inferior_hook (int from_tty)
297 {
298   struct minimal_symbol *msymbol;
299   unsigned int dld_flags, status;
300   asection *shlib_info, *interp_sect;
301   struct objfile *objfile;
302   CORE_ADDR anaddr;
303
304   if (symfile_objfile == NULL)
305     return;
306
307   /* First see if the objfile was dynamically linked.  */
308   shlib_info = bfd_get_section_by_name (symfile_objfile->obfd, ".dynamic");
309   if (!shlib_info)
310     return;
311
312   /* It's got a .dynamic section, make sure it's not empty.  */
313   if (bfd_section_size (symfile_objfile->obfd, shlib_info) == 0)
314     return;
315
316   /* Read in the .dynamic section.  */
317   if (! read_dynamic_info (shlib_info, &dld_cache))
318     error (_("Unable to read the .dynamic section."));
319
320   /* If the libraries were not mapped private, warn the user.  */
321   if ((dld_cache.dld_flags & DT_HP_DEBUG_PRIVATE) == 0)
322     warning
323       (_("\
324 Private mapping of shared library text was not specified\n\
325 by the executable; setting a breakpoint in a shared library which\n\
326 is not privately mapped will not work.  See the HP-UX 11i v3 chatr\n\
327 manpage for methods to privately map shared library text."));
328
329   /* Turn on the flags we care about.  */
330   dld_cache.dld_flags |= DT_HP_DEBUG_CALLBACK;
331   status = target_write_memory (dld_cache.dld_flags_addr,
332                                 (char *) &dld_cache.dld_flags,
333                                 sizeof (dld_cache.dld_flags));
334   if (status != 0)
335     error (_("Unable to modify dynamic linker flags."));
336
337   /* Now we have to create a shared library breakpoint in the dynamic
338      linker.  This can be somewhat tricky since the symbol is inside
339      the dynamic linker (for which we do not have symbols or a base
340      load address!   Luckily I wrote this code for solib.c years ago.  */
341   interp_sect = bfd_get_section_by_name (exec_bfd, ".interp");
342   if (interp_sect)
343     {
344       unsigned int interp_sect_size;
345       char *buf;
346       CORE_ADDR load_addr;
347       bfd *tmp_bfd;
348       CORE_ADDR sym_addr = 0;
349
350       /* Read the contents of the .interp section into a local buffer;
351          the contents specify the dynamic linker this program uses.  */
352       interp_sect_size = bfd_section_size (exec_bfd, interp_sect);
353       buf = alloca (interp_sect_size);
354       bfd_get_section_contents (exec_bfd, interp_sect,
355                                 buf, 0, interp_sect_size);
356
357       /* Now we need to figure out where the dynamic linker was
358          loaded so that we can load its symbols and place a breakpoint
359          in the dynamic linker itself.
360
361          This address is stored on the stack.  However, I've been unable
362          to find any magic formula to find it for Solaris (appears to
363          be trivial on GNU/Linux).  Therefore, we have to try an alternate
364          mechanism to find the dynamic linker's base address.  */
365       tmp_bfd = gdb_bfd_open (buf, gnutarget, -1);
366       if (tmp_bfd == NULL)
367         return;
368
369       /* Make sure the dynamic linker's really a useful object.  */
370       if (!bfd_check_format (tmp_bfd, bfd_object))
371         {
372           warning (_("Unable to grok dynamic linker %s as an object file"),
373                    buf);
374           gdb_bfd_unref (tmp_bfd);
375           return;
376         }
377
378       /* We find the dynamic linker's base address by examining the
379          current pc (which point at the entry point for the dynamic
380          linker) and subtracting the offset of the entry point.
381
382          Also note the breakpoint is the second instruction in the
383          routine.  */
384       load_addr = regcache_read_pc (get_current_regcache ())
385                   - tmp_bfd->start_address;
386       sym_addr = gdb_bfd_lookup_symbol_from_symtab (tmp_bfd, cmp_name,
387                                                     "__dld_break");
388       sym_addr = load_addr + sym_addr + 4;
389       
390       /* Create the shared library breakpoint.  */
391       {
392         struct breakpoint *b
393           = create_solib_event_breakpoint (target_gdbarch (), sym_addr);
394
395         /* The breakpoint is actually hard-coded into the dynamic linker,
396            so we don't need to actually insert a breakpoint instruction
397            there.  In fact, the dynamic linker's code is immutable, even to
398            ttrace, so we shouldn't even try to do that.  For cases like
399            this, we have "permanent" breakpoints.  */
400         make_breakpoint_permanent (b);
401       }
402
403       /* We're done with the temporary bfd.  */
404       gdb_bfd_unref (tmp_bfd);
405     }
406 }
407
408 static void
409 pa64_special_symbol_handling (void)
410 {
411 }
412
413 static struct so_list *
414 pa64_current_sos (void)
415 {
416   struct so_list *head = 0;
417   struct so_list **link_ptr = &head;
418   int dll_index;
419
420   /* Read in the load map pointer if we have not done so already.  */
421   if (! dld_cache.have_read_dld_descriptor)
422     if (! read_dld_descriptor ())
423       return NULL;
424
425   for (dll_index = -1; ; dll_index++)
426     {
427       struct load_module_desc dll_desc;
428       char *dll_path;
429       struct so_list *new;
430       struct cleanup *old_chain;
431
432       if (dll_index == 0)
433         continue;
434
435       /* Read in the load module descriptor.  */
436       if (dlgetmodinfo (dll_index, &dll_desc, sizeof (dll_desc),
437                         pa64_target_read_memory, 0, dld_cache.load_map)
438           == 0)
439         break;
440
441       /* Get the name of the shared library.  */
442       dll_path = (char *)dlgetname (&dll_desc, sizeof (dll_desc),
443                             pa64_target_read_memory,
444                             0, dld_cache.load_map);
445
446       new = (struct so_list *) xmalloc (sizeof (struct so_list));
447       memset (new, 0, sizeof (struct so_list));
448       new->lm_info = (struct lm_info *) xmalloc (sizeof (struct lm_info));
449       memset (new->lm_info, 0, sizeof (struct lm_info));
450
451       strncpy (new->so_name, dll_path, SO_NAME_MAX_PATH_SIZE - 1);
452       new->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
453       strcpy (new->so_original_name, new->so_name);
454
455       memcpy (&new->lm_info->desc, &dll_desc, sizeof (dll_desc));
456
457 #ifdef SOLIB_PA64_DBG
458       {
459         struct load_module_desc *d = &new->lm_info->desc;
460
461         printf ("\n+ library \"%s\" is described at index %d\n", new->so_name, 
462                 dll_index);
463         printf ("    text_base = %s\n", hex_string (d->text_base));
464         printf ("    text_size = %s\n", hex_string (d->text_size));
465         printf ("    data_base = %s\n", hex_string (d->data_base));
466         printf ("    data_size = %s\n", hex_string (d->data_size));
467         printf ("    unwind_base = %s\n", hex_string (d->unwind_base));
468         printf ("    linkage_ptr = %s\n", hex_string (d->linkage_ptr));
469         printf ("    phdr_base = %s\n", hex_string (d->phdr_base));
470         printf ("    tls_size = %s\n", hex_string (d->tls_size));
471         printf ("    tls_start_addr = %s\n", hex_string (d->tls_start_addr));
472         printf ("    unwind_size = %s\n", hex_string (d->unwind_size));
473         printf ("    tls_index = %s\n", hex_string (d->tls_index));
474       }
475 #endif
476
477       /* Link the new object onto the list.  */
478       new->next = NULL;
479       *link_ptr = new;
480       link_ptr = &new->next;
481     }
482
483   return head;
484 }
485
486 static int
487 pa64_open_symbol_file_object (void *from_ttyp)
488 {
489   int from_tty = *(int *)from_ttyp;
490   struct load_module_desc dll_desc;
491   char *dll_path;
492
493   if (symfile_objfile)
494     if (!query (_("Attempt to reload symbols from process? ")))
495       return 0;
496
497   /* Read in the load map pointer if we have not done so already.  */
498   if (! dld_cache.have_read_dld_descriptor)
499     if (! read_dld_descriptor ())
500       return 0;
501
502   /* Read in the load module descriptor.  */
503   if (dlgetmodinfo (0, &dll_desc, sizeof (dll_desc),
504                     pa64_target_read_memory, 0, dld_cache.load_map) == 0)
505     return 0;
506
507   /* Get the name of the shared library.  */
508   dll_path = (char *)dlgetname (&dll_desc, sizeof (dll_desc),
509                                 pa64_target_read_memory,
510                                 0, dld_cache.load_map);
511
512   /* Have a pathname: read the symbol file.  */
513   symbol_file_add_main (dll_path, from_tty);
514
515   return 1;
516 }
517
518 /* Return nonzero if PC is an address inside the dynamic linker.  */
519 static int
520 pa64_in_dynsym_resolve_code (CORE_ADDR pc)
521 {
522   asection *shlib_info;
523
524   if (symfile_objfile == NULL)
525     return 0;
526
527   if (!dld_cache.have_read_dld_descriptor)
528     if (!read_dld_descriptor ())
529       return 0;
530
531   return (pc >= dld_cache.dld_desc.text_base
532           && pc < dld_cache.dld_desc.text_base + dld_cache.dld_desc.text_size);
533 }
534
535
536 /* Return the GOT value for the shared library in which ADDR belongs.  If
537    ADDR isn't in any known shared library, return zero.  */
538
539 static CORE_ADDR
540 pa64_solib_get_got_by_pc (CORE_ADDR addr)
541 {
542   struct so_list *so_list = master_so_list ();
543   CORE_ADDR got_value = 0;
544
545   while (so_list)
546     {
547       if (so_list->lm_info->desc.text_base <= addr
548           && ((so_list->lm_info->desc.text_base
549                + so_list->lm_info->desc.text_size)
550               > addr))
551         {
552           got_value = so_list->lm_info->desc.linkage_ptr;
553           break;
554         }
555       so_list = so_list->next;
556     }
557   return got_value;
558 }
559
560 /* Get some HPUX-specific data from a shared lib.  */
561 static CORE_ADDR
562 pa64_solib_thread_start_addr (struct so_list *so)
563 {
564   return so->lm_info->desc.tls_start_addr;
565 }
566
567
568 /* Return the address of the handle of the shared library in which ADDR
569    belongs.  If ADDR isn't in any known shared library, return zero.  */
570
571 static CORE_ADDR
572 pa64_solib_get_solib_by_pc (CORE_ADDR addr)
573 {
574   struct so_list *so_list = master_so_list ();
575   CORE_ADDR retval = 0;
576
577   while (so_list)
578     {
579       if (so_list->lm_info->desc.text_base <= addr
580           && ((so_list->lm_info->desc.text_base
581                + so_list->lm_info->desc.text_size)
582               > addr))
583         {
584           retval = so_list->lm_info->desc_addr;
585           break;
586         }
587       so_list = so_list->next;
588     }
589   return retval;
590 }
591
592 /* pa64 libraries do not seem to set the section offsets in a standard (i.e.
593    SVr4) way; the text section offset stored in the file doesn't correspond
594    to the place where the library is actually loaded into memory.  Instead,
595    we rely on the dll descriptor to tell us where things were loaded.  */
596 static CORE_ADDR
597 pa64_solib_get_text_base (struct objfile *objfile)
598 {
599   struct so_list *so;
600
601   for (so = master_so_list (); so; so = so->next)
602     if (so->objfile == objfile)
603       return so->lm_info->desc.text_base;
604   
605   return 0;
606 }
607
608 static struct target_so_ops pa64_so_ops;
609
610 extern initialize_file_ftype _initialize_pa64_solib; /* -Wmissing-prototypes */
611
612 void
613 _initialize_pa64_solib (void)
614 {
615   pa64_so_ops.relocate_section_addresses = pa64_relocate_section_addresses;
616   pa64_so_ops.free_so = pa64_free_so;
617   pa64_so_ops.clear_solib = pa64_clear_solib;
618   pa64_so_ops.solib_create_inferior_hook = pa64_solib_create_inferior_hook;
619   pa64_so_ops.special_symbol_handling = pa64_special_symbol_handling;
620   pa64_so_ops.current_sos = pa64_current_sos;
621   pa64_so_ops.open_symbol_file_object = pa64_open_symbol_file_object;
622   pa64_so_ops.in_dynsym_resolve_code = pa64_in_dynsym_resolve_code;
623   pa64_so_ops.bfd_open = solib_bfd_open;
624
625   memset (&dld_cache, 0, sizeof (dld_cache));
626 }
627
628 void pa64_solib_select (struct gdbarch *gdbarch)
629 {
630   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
631
632   set_solib_ops (gdbarch, &pa64_so_ops);
633   tdep->solib_thread_start_addr = pa64_solib_thread_start_addr;
634   tdep->solib_get_got_by_pc = pa64_solib_get_got_by_pc;
635   tdep->solib_get_solib_by_pc = pa64_solib_get_solib_by_pc;
636   tdep->solib_get_text_base = pa64_solib_get_text_base;
637 }
638
639 #else /* HAVE_ELF_HP_H */
640
641 extern initialize_file_ftype _initialize_pa64_solib; /* -Wmissing-prototypes */
642
643 void
644 _initialize_pa64_solib (void)
645 {
646 }
647
648 void pa64_solib_select (struct gdbarch *gdbarch)
649 {
650   /* For a SOM-only target, there is no pa64 solib support.  This is needed
651      for hppa-hpux-tdep.c to build.  */
652   error (_("Cannot select pa64 solib support for this configuration."));
653 }
654 #endif