gdb/
[external/binutils.git] / gdb / solib-dsbt.c
1 /* Handle TIC6X (DSBT) shared libraries for GDB, the GNU Debugger.
2    Copyright (C) 2010-2013 Free Software Foundation, Inc.
3
4    This file is part of GDB.
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 3 of the License, or
9    (at your option) any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
18
19
20 #include "defs.h"
21 #include "gdb_string.h"
22 #include "inferior.h"
23 #include "gdbcore.h"
24 #include "solib.h"
25 #include "solist.h"
26 #include "objfiles.h"
27 #include "symtab.h"
28 #include "language.h"
29 #include "command.h"
30 #include "gdbcmd.h"
31 #include "elf-bfd.h"
32 #include "exceptions.h"
33 #include "gdb_bfd.h"
34
35 #define GOT_MODULE_OFFSET 4
36
37 /* Flag which indicates whether internal debug messages should be printed.  */
38 static unsigned int solib_dsbt_debug = 0;
39
40 /* TIC6X pointers are four bytes wide.  */
41 enum { TIC6X_PTR_SIZE = 4 };
42
43 /* Representation of loadmap and related structs for the TIC6X DSBT.  */
44
45 /* External versions; the size and alignment of the fields should be
46    the same as those on the target.  When loaded, the placement of
47    the bits in each field will be the same as on the target.  */
48 typedef gdb_byte ext_Elf32_Half[2];
49 typedef gdb_byte ext_Elf32_Addr[4];
50 typedef gdb_byte ext_Elf32_Word[4];
51
52 struct ext_elf32_dsbt_loadseg
53 {
54   /* Core address to which the segment is mapped.  */
55   ext_Elf32_Addr addr;
56   /* VMA recorded in the program header.  */
57   ext_Elf32_Addr p_vaddr;
58   /* Size of this segment in memory.  */
59   ext_Elf32_Word p_memsz;
60 };
61
62 struct ext_elf32_dsbt_loadmap {
63   /* Protocol version number, must be zero.  */
64   ext_Elf32_Word version;
65   /* A pointer to the DSBT table; the DSBT size and the index of this
66      module.  */
67   ext_Elf32_Word dsbt_table_ptr;
68   ext_Elf32_Word dsbt_size;
69   ext_Elf32_Word dsbt_index;
70   /* Number of segments in this map.  */
71   ext_Elf32_Word nsegs;
72   /* The actual memory map.  */
73   struct ext_elf32_dsbt_loadseg segs[1 /* nsegs, actually */];
74 };
75
76 /* Internal versions; the types are GDB types and the data in each
77    of the fields is (or will be) decoded from the external struct
78    for ease of consumption.  */
79 struct int_elf32_dsbt_loadseg
80 {
81   /* Core address to which the segment is mapped.  */
82   CORE_ADDR addr;
83   /* VMA recorded in the program header.  */
84   CORE_ADDR p_vaddr;
85   /* Size of this segment in memory.  */
86   long p_memsz;
87 };
88
89 struct int_elf32_dsbt_loadmap
90 {
91   /* Protocol version number, must be zero.  */
92   int version;
93   CORE_ADDR dsbt_table_ptr;
94   /* A pointer to the DSBT table; the DSBT size and the index of this
95      module.  */
96   int dsbt_size, dsbt_index;
97   /* Number of segments in this map.  */
98   int nsegs;
99   /* The actual memory map.  */
100   struct int_elf32_dsbt_loadseg segs[1 /* nsegs, actually */];
101 };
102
103 /* External link_map and elf32_dsbt_loadaddr struct definitions.  */
104
105 typedef gdb_byte ext_ptr[4];
106
107 struct ext_elf32_dsbt_loadaddr
108 {
109   ext_ptr map;                  /* struct elf32_dsbt_loadmap *map; */
110 };
111
112 struct ext_link_map
113 {
114   struct ext_elf32_dsbt_loadaddr l_addr;
115
116   /* Absolute file name object was found in.  */
117   ext_ptr l_name;               /* char *l_name; */
118
119   /* Dynamic section of the shared object.  */
120   ext_ptr l_ld;                 /* ElfW(Dyn) *l_ld; */
121
122   /* Chain of loaded objects.  */
123   ext_ptr l_next, l_prev;       /* struct link_map *l_next, *l_prev; */
124 };
125
126 /* Link map info to include in an allocated so_list entry */
127
128 struct lm_info
129 {
130   /* The loadmap, digested into an easier to use form.  */
131   struct int_elf32_dsbt_loadmap *map;
132 };
133
134 /* Per pspace dsbt specific data.  */
135
136 struct dsbt_info
137 {
138   /* The load map, got value, etc. are not available from the chain
139      of loaded shared objects.  ``main_executable_lm_info'' provides
140      a way to get at this information so that it doesn't need to be
141      frequently recomputed.  Initialized by dsbt_relocate_main_executable.  */
142   struct lm_info *main_executable_lm_info;
143
144   /* Load maps for the main executable and the interpreter.  These are obtained
145      from ptrace.  They are the starting point for getting into the program,
146      and are required to find the solib list with the individual load maps for
147      each module.  */
148   struct int_elf32_dsbt_loadmap *exec_loadmap;
149   struct int_elf32_dsbt_loadmap *interp_loadmap;
150
151   /* Cached value for lm_base, below.  */
152   CORE_ADDR lm_base_cache;
153
154   /* Link map address for main module.  */
155   CORE_ADDR main_lm_addr;
156
157   CORE_ADDR interp_text_sect_low;
158   CORE_ADDR interp_text_sect_high;
159   CORE_ADDR interp_plt_sect_low;
160   CORE_ADDR interp_plt_sect_high;
161 };
162
163 /* Per-program-space data key.  */
164 static const struct program_space_data *solib_dsbt_pspace_data;
165
166 static void
167 dsbt_pspace_data_cleanup (struct program_space *pspace, void *arg)
168 {
169   struct dsbt_info *info;
170
171   info = program_space_data (pspace, solib_dsbt_pspace_data);
172   xfree (info);
173 }
174
175 /* Get the current dsbt data.  If none is found yet, add it now.  This
176    function always returns a valid object.  */
177
178 static struct dsbt_info *
179 get_dsbt_info (void)
180 {
181   struct dsbt_info *info;
182
183   info = program_space_data (current_program_space, solib_dsbt_pspace_data);
184   if (info != NULL)
185     return info;
186
187   info = XZALLOC (struct dsbt_info);
188   set_program_space_data (current_program_space, solib_dsbt_pspace_data, info);
189
190   info->lm_base_cache = 0;
191   info->main_lm_addr = 0;
192
193   return info;
194 }
195
196
197 static void
198 dsbt_print_loadmap (struct int_elf32_dsbt_loadmap *map)
199 {
200   int i;
201
202   if (map == NULL)
203     printf_filtered ("(null)\n");
204   else if (map->version != 0)
205     printf_filtered (_("Unsupported map version: %d\n"), map->version);
206   else
207     {
208       printf_filtered ("version %d\n", map->version);
209
210       for (i = 0; i < map->nsegs; i++)
211         printf_filtered ("%s:%s -> %s:%s\n",
212                          print_core_address (target_gdbarch (),
213                                              map->segs[i].p_vaddr),
214                          print_core_address (target_gdbarch (),
215                                              map->segs[i].p_vaddr
216                                              + map->segs[i].p_memsz),
217                          print_core_address (target_gdbarch (), map->segs[i].addr),
218                          print_core_address (target_gdbarch (), map->segs[i].addr
219                                              + map->segs[i].p_memsz));
220     }
221 }
222
223 /* Decode int_elf32_dsbt_loadmap from BUF.  */
224
225 static struct int_elf32_dsbt_loadmap *
226 decode_loadmap (gdb_byte *buf)
227 {
228   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
229   struct ext_elf32_dsbt_loadmap *ext_ldmbuf;
230   struct int_elf32_dsbt_loadmap *int_ldmbuf;
231
232   int version, seg, nsegs;
233   int int_ldmbuf_size;
234
235   ext_ldmbuf = (struct ext_elf32_dsbt_loadmap *) buf;
236
237   /* Extract the version.  */
238   version = extract_unsigned_integer (ext_ldmbuf->version,
239                                       sizeof ext_ldmbuf->version,
240                                       byte_order);
241   if (version != 0)
242     {
243       /* We only handle version 0.  */
244       return NULL;
245     }
246
247   /* Extract the number of segments.  */
248   nsegs = extract_unsigned_integer (ext_ldmbuf->nsegs,
249                                     sizeof ext_ldmbuf->nsegs,
250                                     byte_order);
251
252   if (nsegs <= 0)
253     return NULL;
254
255   /* Allocate space into which to put information extract from the
256      external loadsegs.  I.e, allocate the internal loadsegs.  */
257   int_ldmbuf_size = (sizeof (struct int_elf32_dsbt_loadmap)
258                      + (nsegs - 1) * sizeof (struct int_elf32_dsbt_loadseg));
259   int_ldmbuf = xmalloc (int_ldmbuf_size);
260
261   /* Place extracted information in internal structs.  */
262   int_ldmbuf->version = version;
263   int_ldmbuf->nsegs = nsegs;
264   for (seg = 0; seg < nsegs; seg++)
265     {
266       int_ldmbuf->segs[seg].addr
267         = extract_unsigned_integer (ext_ldmbuf->segs[seg].addr,
268                                     sizeof (ext_ldmbuf->segs[seg].addr),
269                                     byte_order);
270       int_ldmbuf->segs[seg].p_vaddr
271         = extract_unsigned_integer (ext_ldmbuf->segs[seg].p_vaddr,
272                                     sizeof (ext_ldmbuf->segs[seg].p_vaddr),
273                                     byte_order);
274       int_ldmbuf->segs[seg].p_memsz
275         = extract_unsigned_integer (ext_ldmbuf->segs[seg].p_memsz,
276                                     sizeof (ext_ldmbuf->segs[seg].p_memsz),
277                                     byte_order);
278     }
279
280   xfree (ext_ldmbuf);
281   return int_ldmbuf;
282 }
283
284
285 static struct dsbt_info *get_dsbt_info (void);
286
287 /* Interrogate the Linux kernel to find out where the program was loaded.
288    There are two load maps; one for the executable and one for the
289    interpreter (only in the case of a dynamically linked executable).  */
290
291 static void
292 dsbt_get_initial_loadmaps (void)
293 {
294   gdb_byte *buf;
295   struct dsbt_info *info = get_dsbt_info ();
296
297   if (0 >= target_read_alloc (&current_target, TARGET_OBJECT_FDPIC,
298                               "exec", &buf))
299     {
300       info->exec_loadmap = NULL;
301       error (_("Error reading DSBT exec loadmap"));
302     }
303   info->exec_loadmap = decode_loadmap (buf);
304   if (solib_dsbt_debug)
305     dsbt_print_loadmap (info->exec_loadmap);
306
307   if (0 >= target_read_alloc (&current_target, TARGET_OBJECT_FDPIC,
308                               "interp", &buf))
309     {
310       info->interp_loadmap = NULL;
311       error (_("Error reading DSBT interp loadmap"));
312     }
313   info->interp_loadmap = decode_loadmap (buf);
314   if (solib_dsbt_debug)
315     dsbt_print_loadmap (info->interp_loadmap);
316 }
317
318 /* Given address LDMADDR, fetch and decode the loadmap at that address.
319    Return NULL if there is a problem reading the target memory or if
320    there doesn't appear to be a loadmap at the given address.  The
321    allocated space (representing the loadmap) returned by this
322    function may be freed via a single call to xfree.  */
323
324 static struct int_elf32_dsbt_loadmap *
325 fetch_loadmap (CORE_ADDR ldmaddr)
326 {
327   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
328   struct ext_elf32_dsbt_loadmap ext_ldmbuf_partial;
329   struct ext_elf32_dsbt_loadmap *ext_ldmbuf;
330   struct int_elf32_dsbt_loadmap *int_ldmbuf;
331   int ext_ldmbuf_size, int_ldmbuf_size;
332   int version, seg, nsegs;
333
334   /* Fetch initial portion of the loadmap.  */
335   if (target_read_memory (ldmaddr, (gdb_byte *) &ext_ldmbuf_partial,
336                           sizeof ext_ldmbuf_partial))
337     {
338       /* Problem reading the target's memory.  */
339       return NULL;
340     }
341
342   /* Extract the version.  */
343   version = extract_unsigned_integer (ext_ldmbuf_partial.version,
344                                       sizeof ext_ldmbuf_partial.version,
345                                       byte_order);
346   if (version != 0)
347     {
348       /* We only handle version 0.  */
349       return NULL;
350     }
351
352   /* Extract the number of segments.  */
353   nsegs = extract_unsigned_integer (ext_ldmbuf_partial.nsegs,
354                                     sizeof ext_ldmbuf_partial.nsegs,
355                                     byte_order);
356
357   if (nsegs <= 0)
358     return NULL;
359
360   /* Allocate space for the complete (external) loadmap.  */
361   ext_ldmbuf_size = sizeof (struct ext_elf32_dsbt_loadmap)
362     + (nsegs - 1) * sizeof (struct ext_elf32_dsbt_loadseg);
363   ext_ldmbuf = xmalloc (ext_ldmbuf_size);
364
365   /* Copy over the portion of the loadmap that's already been read.  */
366   memcpy (ext_ldmbuf, &ext_ldmbuf_partial, sizeof ext_ldmbuf_partial);
367
368   /* Read the rest of the loadmap from the target.  */
369   if (target_read_memory (ldmaddr + sizeof ext_ldmbuf_partial,
370                           (gdb_byte *) ext_ldmbuf + sizeof ext_ldmbuf_partial,
371                           ext_ldmbuf_size - sizeof ext_ldmbuf_partial))
372     {
373       /* Couldn't read rest of the loadmap.  */
374       xfree (ext_ldmbuf);
375       return NULL;
376     }
377
378   /* Allocate space into which to put information extract from the
379      external loadsegs.  I.e, allocate the internal loadsegs.  */
380   int_ldmbuf_size = sizeof (struct int_elf32_dsbt_loadmap)
381     + (nsegs - 1) * sizeof (struct int_elf32_dsbt_loadseg);
382   int_ldmbuf = xmalloc (int_ldmbuf_size);
383
384   /* Place extracted information in internal structs.  */
385   int_ldmbuf->version = version;
386   int_ldmbuf->nsegs = nsegs;
387   for (seg = 0; seg < nsegs; seg++)
388     {
389       int_ldmbuf->segs[seg].addr
390         = extract_unsigned_integer (ext_ldmbuf->segs[seg].addr,
391                                     sizeof (ext_ldmbuf->segs[seg].addr),
392                                     byte_order);
393       int_ldmbuf->segs[seg].p_vaddr
394         = extract_unsigned_integer (ext_ldmbuf->segs[seg].p_vaddr,
395                                     sizeof (ext_ldmbuf->segs[seg].p_vaddr),
396                                     byte_order);
397       int_ldmbuf->segs[seg].p_memsz
398         = extract_unsigned_integer (ext_ldmbuf->segs[seg].p_memsz,
399                                     sizeof (ext_ldmbuf->segs[seg].p_memsz),
400                                     byte_order);
401     }
402
403   xfree (ext_ldmbuf);
404   return int_ldmbuf;
405 }
406
407 static void dsbt_relocate_main_executable (void);
408 static int enable_break (void);
409
410 /* Scan for DYNTAG in .dynamic section of ABFD. If DYNTAG is found 1 is
411    returned and the corresponding PTR is set.  */
412
413 static int
414 scan_dyntag (int dyntag, bfd *abfd, CORE_ADDR *ptr)
415 {
416   int arch_size, step, sect_size;
417   long dyn_tag;
418   CORE_ADDR dyn_ptr, dyn_addr;
419   gdb_byte *bufend, *bufstart, *buf;
420   Elf32_External_Dyn *x_dynp_32;
421   Elf64_External_Dyn *x_dynp_64;
422   struct bfd_section *sect;
423   struct target_section *target_section;
424
425   if (abfd == NULL)
426     return 0;
427
428   if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
429     return 0;
430
431   arch_size = bfd_get_arch_size (abfd);
432   if (arch_size == -1)
433     return 0;
434
435   /* Find the start address of the .dynamic section.  */
436   sect = bfd_get_section_by_name (abfd, ".dynamic");
437   if (sect == NULL)
438     return 0;
439
440   for (target_section = current_target_sections->sections;
441        target_section < current_target_sections->sections_end;
442        target_section++)
443     if (sect == target_section->the_bfd_section)
444       break;
445   if (target_section < current_target_sections->sections_end)
446     dyn_addr = target_section->addr;
447   else
448     {
449       /* ABFD may come from OBJFILE acting only as a symbol file without being
450          loaded into the target (see add_symbol_file_command).  This case is
451          such fallback to the file VMA address without the possibility of
452          having the section relocated to its actual in-memory address.  */
453
454       dyn_addr = bfd_section_vma (abfd, sect);
455     }
456
457   /* Read in .dynamic from the BFD.  We will get the actual value
458      from memory later.  */
459   sect_size = bfd_section_size (abfd, sect);
460   buf = bufstart = alloca (sect_size);
461   if (!bfd_get_section_contents (abfd, sect,
462                                  buf, 0, sect_size))
463     return 0;
464
465   /* Iterate over BUF and scan for DYNTAG.  If found, set PTR and return.  */
466   step = (arch_size == 32) ? sizeof (Elf32_External_Dyn)
467                            : sizeof (Elf64_External_Dyn);
468   for (bufend = buf + sect_size;
469        buf < bufend;
470        buf += step)
471   {
472     if (arch_size == 32)
473       {
474         x_dynp_32 = (Elf32_External_Dyn *) buf;
475         dyn_tag = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp_32->d_tag);
476         dyn_ptr = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp_32->d_un.d_ptr);
477       }
478     else
479       {
480         x_dynp_64 = (Elf64_External_Dyn *) buf;
481         dyn_tag = bfd_h_get_64 (abfd, (bfd_byte *) x_dynp_64->d_tag);
482         dyn_ptr = bfd_h_get_64 (abfd, (bfd_byte *) x_dynp_64->d_un.d_ptr);
483       }
484      if (dyn_tag == DT_NULL)
485        return 0;
486      if (dyn_tag == dyntag)
487        {
488          /* If requested, try to read the runtime value of this .dynamic
489             entry.  */
490          if (ptr)
491            {
492              struct type *ptr_type;
493              gdb_byte ptr_buf[8];
494              CORE_ADDR ptr_addr;
495
496              ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
497              ptr_addr = dyn_addr + (buf - bufstart) + arch_size / 8;
498              if (target_read_memory (ptr_addr, ptr_buf, arch_size / 8) == 0)
499                dyn_ptr = extract_typed_address (ptr_buf, ptr_type);
500              *ptr = dyn_ptr;
501            }
502          return 1;
503        }
504   }
505
506   return 0;
507 }
508
509 /* If no open symbol file, attempt to locate and open the main symbol
510    file.
511
512    If FROM_TTYP dereferences to a non-zero integer, allow messages to
513    be printed.  This parameter is a pointer rather than an int because
514    open_symbol_file_object is called via catch_errors and
515    catch_errors requires a pointer argument. */
516
517 static int
518 open_symbol_file_object (void *from_ttyp)
519 {
520   /* Unimplemented.  */
521   return 0;
522 }
523
524 /* Given a loadmap and an address, return the displacement needed
525    to relocate the address.  */
526
527 static CORE_ADDR
528 displacement_from_map (struct int_elf32_dsbt_loadmap *map,
529                        CORE_ADDR addr)
530 {
531   int seg;
532
533   for (seg = 0; seg < map->nsegs; seg++)
534     if (map->segs[seg].p_vaddr <= addr
535         && addr < map->segs[seg].p_vaddr + map->segs[seg].p_memsz)
536       return map->segs[seg].addr - map->segs[seg].p_vaddr;
537
538   return 0;
539 }
540
541 /* Return the address from which the link map chain may be found.  On
542    DSBT, a pointer to the start of the link map will be located at the
543    word found at base of GOT + GOT_MODULE_OFFSET.
544
545    The base of GOT may be found in a number of ways.  Assuming that the
546    main executable has already been relocated,
547    1 The easiest way to find this value is to look up the address of
548    _GLOBAL_OFFSET_TABLE_.
549    2 The other way is to look for tag DT_PLTGOT, which contains the virtual
550    address of Global Offset Table.  .*/
551
552 static CORE_ADDR
553 lm_base (void)
554 {
555   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
556   struct minimal_symbol *got_sym;
557   CORE_ADDR addr;
558   gdb_byte buf[TIC6X_PTR_SIZE];
559   struct dsbt_info *info = get_dsbt_info ();
560
561   /* One of our assumptions is that the main executable has been relocated.
562      Bail out if this has not happened.  (Note that post_create_inferior
563      in infcmd.c will call solib_add prior to solib_create_inferior_hook.
564      If we allow this to happen, lm_base_cache will be initialized with
565      a bogus value.  */
566   if (info->main_executable_lm_info == 0)
567     return 0;
568
569   /* If we already have a cached value, return it.  */
570   if (info->lm_base_cache)
571     return info->lm_base_cache;
572
573   got_sym = lookup_minimal_symbol ("_GLOBAL_OFFSET_TABLE_", NULL,
574                                    symfile_objfile);
575
576   if (got_sym != 0)
577     {
578       addr = SYMBOL_VALUE_ADDRESS (got_sym);
579       if (solib_dsbt_debug)
580         fprintf_unfiltered (gdb_stdlog,
581                             "lm_base: get addr %x by _GLOBAL_OFFSET_TABLE_.\n",
582                             (unsigned int) addr);
583     }
584   else if (scan_dyntag (DT_PLTGOT, exec_bfd, &addr))
585     {
586       struct int_elf32_dsbt_loadmap *ldm;
587
588       dsbt_get_initial_loadmaps ();
589       ldm = info->exec_loadmap;
590       addr += displacement_from_map (ldm, addr);
591       if (solib_dsbt_debug)
592         fprintf_unfiltered (gdb_stdlog,
593                             "lm_base: get addr %x by DT_PLTGOT.\n",
594                             (unsigned int) addr);
595     }
596   else
597     {
598       if (solib_dsbt_debug)
599         fprintf_unfiltered (gdb_stdlog,
600                             "lm_base: _GLOBAL_OFFSET_TABLE_ not found.\n");
601       return 0;
602     }
603   addr += GOT_MODULE_OFFSET;
604
605   if (solib_dsbt_debug)
606     fprintf_unfiltered (gdb_stdlog,
607                         "lm_base: _GLOBAL_OFFSET_TABLE_ + %d = %s\n",
608                         GOT_MODULE_OFFSET, hex_string_custom (addr, 8));
609
610   if (target_read_memory (addr, buf, sizeof buf) != 0)
611     return 0;
612   info->lm_base_cache = extract_unsigned_integer (buf, sizeof buf, byte_order);
613
614   if (solib_dsbt_debug)
615     fprintf_unfiltered (gdb_stdlog,
616                         "lm_base: lm_base_cache = %s\n",
617                         hex_string_custom (info->lm_base_cache, 8));
618
619   return info->lm_base_cache;
620 }
621
622
623 /* Build a list of `struct so_list' objects describing the shared
624    objects currently loaded in the inferior.  This list does not
625    include an entry for the main executable file.
626
627    Note that we only gather information directly available from the
628    inferior --- we don't examine any of the shared library files
629    themselves.  The declaration of `struct so_list' says which fields
630    we provide values for.  */
631
632 static struct so_list *
633 dsbt_current_sos (void)
634 {
635   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
636   CORE_ADDR lm_addr;
637   struct so_list *sos_head = NULL;
638   struct so_list **sos_next_ptr = &sos_head;
639   struct dsbt_info *info = get_dsbt_info ();
640
641   /* Make sure that the main executable has been relocated.  This is
642      required in order to find the address of the global offset table,
643      which in turn is used to find the link map info.  (See lm_base
644      for details.)
645
646      Note that the relocation of the main executable is also performed
647      by solib_create_inferior_hook, however, in the case of core
648      files, this hook is called too late in order to be of benefit to
649      solib_add.  solib_add eventually calls this function,
650      dsbt_current_sos, and also precedes the call to
651      solib_create_inferior_hook.   (See post_create_inferior in
652      infcmd.c.)  */
653   if (info->main_executable_lm_info == 0 && core_bfd != NULL)
654     dsbt_relocate_main_executable ();
655
656   /* Locate the address of the first link map struct.  */
657   lm_addr = lm_base ();
658
659   /* We have at least one link map entry.  Fetch the the lot of them,
660      building the solist chain.  */
661   while (lm_addr)
662     {
663       struct ext_link_map lm_buf;
664       ext_Elf32_Word indexword;
665       CORE_ADDR map_addr;
666       int dsbt_index;
667       int ret;
668
669       if (solib_dsbt_debug)
670         fprintf_unfiltered (gdb_stdlog,
671                             "current_sos: reading link_map entry at %s\n",
672                             hex_string_custom (lm_addr, 8));
673
674       ret = target_read_memory (lm_addr, (gdb_byte *) &lm_buf, sizeof (lm_buf));
675       if (ret)
676         {
677           warning (_("dsbt_current_sos: Unable to read link map entry."
678                      "  Shared object chain may be incomplete."));
679           break;
680         }
681
682       /* Fetch the load map address.  */
683       map_addr = extract_unsigned_integer (lm_buf.l_addr.map,
684                                            sizeof lm_buf.l_addr.map,
685                                            byte_order);
686
687       ret = target_read_memory (map_addr + 12, (gdb_byte *) &indexword,
688                                 sizeof indexword);
689       if (ret)
690         {
691           warning (_("dsbt_current_sos: Unable to read dsbt index."
692                      "  Shared object chain may be incomplete."));
693           break;
694         }
695       dsbt_index = extract_unsigned_integer (indexword, sizeof indexword,
696                                              byte_order);
697
698       /* If the DSBT index is zero, then we're looking at the entry
699          for the main executable.  By convention, we don't include
700          this in the list of shared objects.  */
701       if (dsbt_index != 0)
702         {
703           int errcode;
704           char *name_buf;
705           struct int_elf32_dsbt_loadmap *loadmap;
706           struct so_list *sop;
707           CORE_ADDR addr;
708
709           loadmap = fetch_loadmap (map_addr);
710           if (loadmap == NULL)
711             {
712               warning (_("dsbt_current_sos: Unable to fetch load map."
713                          "  Shared object chain may be incomplete."));
714               break;
715             }
716
717           sop = xcalloc (1, sizeof (struct so_list));
718           sop->lm_info = xcalloc (1, sizeof (struct lm_info));
719           sop->lm_info->map = loadmap;
720           /* Fetch the name.  */
721           addr = extract_unsigned_integer (lm_buf.l_name,
722                                            sizeof (lm_buf.l_name),
723                                            byte_order);
724           target_read_string (addr, &name_buf, SO_NAME_MAX_PATH_SIZE - 1,
725                               &errcode);
726
727           if (errcode != 0)
728             warning (_("Can't read pathname for link map entry: %s."),
729                      safe_strerror (errcode));
730           else
731             {
732               if (solib_dsbt_debug)
733                 fprintf_unfiltered (gdb_stdlog, "current_sos: name = %s\n",
734                                     name_buf);
735
736               strncpy (sop->so_name, name_buf, SO_NAME_MAX_PATH_SIZE - 1);
737               sop->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
738               xfree (name_buf);
739               strcpy (sop->so_original_name, sop->so_name);
740             }
741
742           *sos_next_ptr = sop;
743           sos_next_ptr = &sop->next;
744         }
745       else
746         {
747           info->main_lm_addr = lm_addr;
748         }
749
750       lm_addr = extract_unsigned_integer (lm_buf.l_next,
751                                           sizeof (lm_buf.l_next), byte_order);
752     }
753
754   return sos_head;
755 }
756
757 /* Return 1 if PC lies in the dynamic symbol resolution code of the
758    run time loader.  */
759
760 static int
761 dsbt_in_dynsym_resolve_code (CORE_ADDR pc)
762 {
763   struct dsbt_info *info = get_dsbt_info ();
764
765   return ((pc >= info->interp_text_sect_low && pc < info->interp_text_sect_high)
766           || (pc >= info->interp_plt_sect_low && pc < info->interp_plt_sect_high)
767           || in_plt_section (pc, NULL));
768 }
769
770 /* Print a warning about being unable to set the dynamic linker
771    breakpoint.  */
772
773 static void
774 enable_break_failure_warning (void)
775 {
776   warning (_("Unable to find dynamic linker breakpoint function.\n"
777              "GDB will be unable to debug shared library initializers\n"
778              "and track explicitly loaded dynamic code."));
779 }
780
781 /* Helper function for gdb_bfd_lookup_symbol.  */
782
783 static int
784 cmp_name (asymbol *sym, void *data)
785 {
786   return (strcmp (sym->name, (const char *) data) == 0);
787 }
788
789 /* The dynamic linkers has, as part of its debugger interface, support
790    for arranging for the inferior to hit a breakpoint after mapping in
791    the shared libraries.  This function enables that breakpoint.
792
793    On the TIC6X, using the shared library (DSBT), GDB can try to place
794    a breakpoint on '_dl_debug_state' to monitor the shared library
795    event.  */
796
797 static int
798 enable_break (void)
799 {
800   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
801   asection *interp_sect;
802   struct dsbt_info *info;
803
804   if (exec_bfd == NULL)
805     return 0;
806
807   if (!target_has_execution)
808     return 0;
809
810   info = get_dsbt_info ();
811
812   info->interp_text_sect_low = 0;
813   info->interp_text_sect_high = 0;
814   info->interp_plt_sect_low = 0;
815   info->interp_plt_sect_high = 0;
816
817   /* Find the .interp section; if not found, warn the user and drop
818      into the old breakpoint at symbol code.  */
819   interp_sect = bfd_get_section_by_name (exec_bfd, ".interp");
820   if (interp_sect)
821     {
822       unsigned int interp_sect_size;
823       char *buf;
824       bfd *tmp_bfd = NULL;
825       CORE_ADDR addr;
826       gdb_byte addr_buf[TIC6X_PTR_SIZE];
827       struct int_elf32_dsbt_loadmap *ldm;
828       volatile struct gdb_exception ex;
829       int ret;
830
831       /* Read the contents of the .interp section into a local buffer;
832          the contents specify the dynamic linker this program uses.  */
833       interp_sect_size = bfd_section_size (exec_bfd, interp_sect);
834       buf = alloca (interp_sect_size);
835       bfd_get_section_contents (exec_bfd, interp_sect,
836                                 buf, 0, interp_sect_size);
837
838       /* Now we need to figure out where the dynamic linker was
839          loaded so that we can load its symbols and place a breakpoint
840          in the dynamic linker itself.  */
841
842       TRY_CATCH (ex, RETURN_MASK_ALL)
843         {
844           tmp_bfd = solib_bfd_open (buf);
845         }
846       if (tmp_bfd == NULL)
847         {
848           enable_break_failure_warning ();
849           return 0;
850         }
851
852       dsbt_get_initial_loadmaps ();
853       ldm = info->interp_loadmap;
854
855       /* Record the relocated start and end address of the dynamic linker
856          text and plt section for dsbt_in_dynsym_resolve_code.  */
857       interp_sect = bfd_get_section_by_name (tmp_bfd, ".text");
858       if (interp_sect)
859         {
860           info->interp_text_sect_low
861             = bfd_section_vma (tmp_bfd, interp_sect);
862           info->interp_text_sect_low
863             += displacement_from_map (ldm, info->interp_text_sect_low);
864           info->interp_text_sect_high
865             = info->interp_text_sect_low
866             + bfd_section_size (tmp_bfd, interp_sect);
867         }
868       interp_sect = bfd_get_section_by_name (tmp_bfd, ".plt");
869       if (interp_sect)
870         {
871           info->interp_plt_sect_low =
872             bfd_section_vma (tmp_bfd, interp_sect);
873           info->interp_plt_sect_low
874             += displacement_from_map (ldm, info->interp_plt_sect_low);
875           info->interp_plt_sect_high =
876             info->interp_plt_sect_low + bfd_section_size (tmp_bfd, interp_sect);
877         }
878
879       addr = gdb_bfd_lookup_symbol (tmp_bfd, cmp_name, "_dl_debug_state");
880       if (addr != 0)
881         {
882           if (solib_dsbt_debug)
883             fprintf_unfiltered (gdb_stdlog,
884                                 "enable_break: _dl_debug_state (prior to relocation) = %s\n",
885                                 hex_string_custom (addr, 8));
886           addr += displacement_from_map (ldm, addr);
887
888           if (solib_dsbt_debug)
889             fprintf_unfiltered (gdb_stdlog,
890                                 "enable_break: _dl_debug_state (after relocation) = %s\n",
891                                 hex_string_custom (addr, 8));
892
893           /* Now (finally!) create the solib breakpoint.  */
894           create_solib_event_breakpoint (target_gdbarch (), addr);
895
896           ret = 1;
897         }
898       else
899         {
900           if (solib_dsbt_debug)
901             fprintf_unfiltered (gdb_stdlog,
902                                 "enable_break: _dl_debug_state is not found\n");
903           ret = 0;
904         }
905
906       /* We're done with the temporary bfd.  */
907       gdb_bfd_unref (tmp_bfd);
908
909       /* We're also done with the loadmap.  */
910       xfree (ldm);
911
912       return ret;
913     }
914
915   /* Tell the user we couldn't set a dynamic linker breakpoint.  */
916   enable_break_failure_warning ();
917
918   /* Failure return.  */
919   return 0;
920 }
921
922 /* Once the symbols from a shared object have been loaded in the usual
923    way, we are called to do any system specific symbol handling that
924    is needed.  */
925
926 static void
927 dsbt_special_symbol_handling (void)
928 {
929 }
930
931 static void
932 dsbt_relocate_main_executable (void)
933 {
934   struct int_elf32_dsbt_loadmap *ldm;
935   struct cleanup *old_chain;
936   struct section_offsets *new_offsets;
937   int changed;
938   struct obj_section *osect;
939   struct dsbt_info *info = get_dsbt_info ();
940
941   dsbt_get_initial_loadmaps ();
942   ldm = info->exec_loadmap;
943
944   xfree (info->main_executable_lm_info);
945   info->main_executable_lm_info = xcalloc (1, sizeof (struct lm_info));
946   info->main_executable_lm_info->map = ldm;
947
948   new_offsets = xcalloc (symfile_objfile->num_sections,
949                          sizeof (struct section_offsets));
950   old_chain = make_cleanup (xfree, new_offsets);
951   changed = 0;
952
953   ALL_OBJFILE_OSECTIONS (symfile_objfile, osect)
954     {
955       CORE_ADDR orig_addr, addr, offset;
956       int osect_idx;
957       int seg;
958
959       osect_idx = osect - symfile_objfile->sections;
960
961       /* Current address of section.  */
962       addr = obj_section_addr (osect);
963       /* Offset from where this section started.  */
964       offset = ANOFFSET (symfile_objfile->section_offsets, osect_idx);
965       /* Original address prior to any past relocations.  */
966       orig_addr = addr - offset;
967
968       for (seg = 0; seg < ldm->nsegs; seg++)
969         {
970           if (ldm->segs[seg].p_vaddr <= orig_addr
971               && orig_addr < ldm->segs[seg].p_vaddr + ldm->segs[seg].p_memsz)
972             {
973               new_offsets->offsets[osect_idx]
974                 = ldm->segs[seg].addr - ldm->segs[seg].p_vaddr;
975
976               if (new_offsets->offsets[osect_idx] != offset)
977                 changed = 1;
978               break;
979             }
980         }
981     }
982
983   if (changed)
984     objfile_relocate (symfile_objfile, new_offsets);
985
986   do_cleanups (old_chain);
987
988   /* Now that symfile_objfile has been relocated, we can compute the
989      GOT value and stash it away.  */
990 }
991
992 /* When gdb starts up the inferior, it nurses it along (through the
993    shell) until it is ready to execute it's first instruction.  At this
994    point, this function gets called via solib_create_inferior_hook.
995
996    For the DSBT shared library, the main executable needs to be relocated.
997    The shared library breakpoints also need to be enabled.  */
998
999 static void
1000 dsbt_solib_create_inferior_hook (int from_tty)
1001 {
1002   /* Relocate main executable.  */
1003   dsbt_relocate_main_executable ();
1004
1005   /* Enable shared library breakpoints.  */
1006   if (!enable_break ())
1007     {
1008       warning (_("shared library handler failed to enable breakpoint"));
1009       return;
1010     }
1011 }
1012
1013 static void
1014 dsbt_clear_solib (void)
1015 {
1016   struct dsbt_info *info = get_dsbt_info ();
1017
1018   info->lm_base_cache = 0;
1019   info->main_lm_addr = 0;
1020   if (info->main_executable_lm_info != 0)
1021     {
1022       xfree (info->main_executable_lm_info->map);
1023       xfree (info->main_executable_lm_info);
1024       info->main_executable_lm_info = 0;
1025     }
1026 }
1027
1028 static void
1029 dsbt_free_so (struct so_list *so)
1030 {
1031   xfree (so->lm_info->map);
1032   xfree (so->lm_info);
1033 }
1034
1035 static void
1036 dsbt_relocate_section_addresses (struct so_list *so,
1037                                  struct target_section *sec)
1038 {
1039   int seg;
1040   struct int_elf32_dsbt_loadmap *map;
1041
1042   map = so->lm_info->map;
1043
1044   for (seg = 0; seg < map->nsegs; seg++)
1045     {
1046       if (map->segs[seg].p_vaddr <= sec->addr
1047           && sec->addr < map->segs[seg].p_vaddr + map->segs[seg].p_memsz)
1048         {
1049           CORE_ADDR displ = map->segs[seg].addr - map->segs[seg].p_vaddr;
1050
1051           sec->addr += displ;
1052           sec->endaddr += displ;
1053           break;
1054         }
1055     }
1056 }
1057 static void
1058 show_dsbt_debug (struct ui_file *file, int from_tty,
1059                  struct cmd_list_element *c, const char *value)
1060 {
1061   fprintf_filtered (file, _("solib-dsbt debugging is %s.\n"), value);
1062 }
1063
1064 struct target_so_ops dsbt_so_ops;
1065
1066 /* Provide a prototype to silence -Wmissing-prototypes.  */
1067 extern initialize_file_ftype _initialize_dsbt_solib;
1068
1069 void
1070 _initialize_dsbt_solib (void)
1071 {
1072   solib_dsbt_pspace_data
1073     = register_program_space_data_with_cleanup (NULL, dsbt_pspace_data_cleanup);
1074
1075   dsbt_so_ops.relocate_section_addresses = dsbt_relocate_section_addresses;
1076   dsbt_so_ops.free_so = dsbt_free_so;
1077   dsbt_so_ops.clear_solib = dsbt_clear_solib;
1078   dsbt_so_ops.solib_create_inferior_hook = dsbt_solib_create_inferior_hook;
1079   dsbt_so_ops.special_symbol_handling = dsbt_special_symbol_handling;
1080   dsbt_so_ops.current_sos = dsbt_current_sos;
1081   dsbt_so_ops.open_symbol_file_object = open_symbol_file_object;
1082   dsbt_so_ops.in_dynsym_resolve_code = dsbt_in_dynsym_resolve_code;
1083   dsbt_so_ops.bfd_open = solib_bfd_open;
1084
1085   /* Debug this file's internals.  */
1086   add_setshow_zuinteger_cmd ("solib-dsbt", class_maintenance,
1087                              &solib_dsbt_debug, _("\
1088 Set internal debugging of shared library code for DSBT ELF."), _("\
1089 Show internal debugging of shared library code for DSBT ELF."), _("\
1090 When non-zero, DSBT solib specific internal debugging is enabled."),
1091                              NULL,
1092                              show_dsbt_debug,
1093                              &setdebuglist, &showdebuglist);
1094 }