1 /* Handle TIC6X (DSBT) shared libraries for GDB, the GNU Debugger.
2 Copyright (C) 2010-2017 Free Software Foundation, Inc.
4 This file is part of GDB.
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.
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.
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/>. */
33 #define GOT_MODULE_OFFSET 4
35 /* Flag which indicates whether internal debug messages should be printed. */
36 static unsigned int solib_dsbt_debug
= 0;
38 /* TIC6X pointers are four bytes wide. */
39 enum { TIC6X_PTR_SIZE
= 4 };
41 /* Representation of loadmap and related structs for the TIC6X DSBT. */
43 /* External versions; the size and alignment of the fields should be
44 the same as those on the target. When loaded, the placement of
45 the bits in each field will be the same as on the target. */
46 typedef gdb_byte ext_Elf32_Half
[2];
47 typedef gdb_byte ext_Elf32_Addr
[4];
48 typedef gdb_byte ext_Elf32_Word
[4];
50 struct ext_elf32_dsbt_loadseg
52 /* Core address to which the segment is mapped. */
54 /* VMA recorded in the program header. */
55 ext_Elf32_Addr p_vaddr
;
56 /* Size of this segment in memory. */
57 ext_Elf32_Word p_memsz
;
60 struct ext_elf32_dsbt_loadmap
{
61 /* Protocol version number, must be zero. */
62 ext_Elf32_Word version
;
63 /* A pointer to the DSBT table; the DSBT size and the index of this
65 ext_Elf32_Word dsbt_table_ptr
;
66 ext_Elf32_Word dsbt_size
;
67 ext_Elf32_Word dsbt_index
;
68 /* Number of segments in this map. */
70 /* The actual memory map. */
71 struct ext_elf32_dsbt_loadseg segs
[1 /* nsegs, actually */];
74 /* Internal versions; the types are GDB types and the data in each
75 of the fields is (or will be) decoded from the external struct
76 for ease of consumption. */
77 struct int_elf32_dsbt_loadseg
79 /* Core address to which the segment is mapped. */
81 /* VMA recorded in the program header. */
83 /* Size of this segment in memory. */
87 struct int_elf32_dsbt_loadmap
89 /* Protocol version number, must be zero. */
91 CORE_ADDR dsbt_table_ptr
;
92 /* A pointer to the DSBT table; the DSBT size and the index of this
94 int dsbt_size
, dsbt_index
;
95 /* Number of segments in this map. */
97 /* The actual memory map. */
98 struct int_elf32_dsbt_loadseg segs
[1 /* nsegs, actually */];
101 /* External link_map and elf32_dsbt_loadaddr struct definitions. */
103 typedef gdb_byte ext_ptr
[4];
105 struct ext_elf32_dsbt_loadaddr
107 ext_ptr map
; /* struct elf32_dsbt_loadmap *map; */
112 struct ext_elf32_dsbt_loadaddr l_addr
;
114 /* Absolute file name object was found in. */
115 ext_ptr l_name
; /* char *l_name; */
117 /* Dynamic section of the shared object. */
118 ext_ptr l_ld
; /* ElfW(Dyn) *l_ld; */
120 /* Chain of loaded objects. */
121 ext_ptr l_next
, l_prev
; /* struct link_map *l_next, *l_prev; */
124 /* Link map info to include in an allocated so_list entry */
128 /* The loadmap, digested into an easier to use form. */
129 struct int_elf32_dsbt_loadmap
*map
;
132 /* Per pspace dsbt specific data. */
136 /* The load map, got value, etc. are not available from the chain
137 of loaded shared objects. ``main_executable_lm_info'' provides
138 a way to get at this information so that it doesn't need to be
139 frequently recomputed. Initialized by dsbt_relocate_main_executable. */
140 struct lm_info
*main_executable_lm_info
;
142 /* Load maps for the main executable and the interpreter. These are obtained
143 from ptrace. They are the starting point for getting into the program,
144 and are required to find the solib list with the individual load maps for
146 struct int_elf32_dsbt_loadmap
*exec_loadmap
;
147 struct int_elf32_dsbt_loadmap
*interp_loadmap
;
149 /* Cached value for lm_base, below. */
150 CORE_ADDR lm_base_cache
;
152 /* Link map address for main module. */
153 CORE_ADDR main_lm_addr
;
155 CORE_ADDR interp_text_sect_low
;
156 CORE_ADDR interp_text_sect_high
;
157 CORE_ADDR interp_plt_sect_low
;
158 CORE_ADDR interp_plt_sect_high
;
161 /* Per-program-space data key. */
162 static const struct program_space_data
*solib_dsbt_pspace_data
;
165 dsbt_pspace_data_cleanup (struct program_space
*pspace
, void *arg
)
170 /* Get the current dsbt data. If none is found yet, add it now. This
171 function always returns a valid object. */
173 static struct dsbt_info
*
176 struct dsbt_info
*info
;
178 info
= (struct dsbt_info
*) program_space_data (current_program_space
,
179 solib_dsbt_pspace_data
);
183 info
= XCNEW (struct dsbt_info
);
184 set_program_space_data (current_program_space
, solib_dsbt_pspace_data
, info
);
186 info
->lm_base_cache
= 0;
187 info
->main_lm_addr
= 0;
194 dsbt_print_loadmap (struct int_elf32_dsbt_loadmap
*map
)
199 printf_filtered ("(null)\n");
200 else if (map
->version
!= 0)
201 printf_filtered (_("Unsupported map version: %d\n"), map
->version
);
204 printf_filtered ("version %d\n", map
->version
);
206 for (i
= 0; i
< map
->nsegs
; i
++)
207 printf_filtered ("%s:%s -> %s:%s\n",
208 print_core_address (target_gdbarch (),
209 map
->segs
[i
].p_vaddr
),
210 print_core_address (target_gdbarch (),
212 + map
->segs
[i
].p_memsz
),
213 print_core_address (target_gdbarch (), map
->segs
[i
].addr
),
214 print_core_address (target_gdbarch (), map
->segs
[i
].addr
215 + map
->segs
[i
].p_memsz
));
219 /* Decode int_elf32_dsbt_loadmap from BUF. */
221 static struct int_elf32_dsbt_loadmap
*
222 decode_loadmap (gdb_byte
*buf
)
224 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
225 struct ext_elf32_dsbt_loadmap
*ext_ldmbuf
;
226 struct int_elf32_dsbt_loadmap
*int_ldmbuf
;
228 int version
, seg
, nsegs
;
231 ext_ldmbuf
= (struct ext_elf32_dsbt_loadmap
*) buf
;
233 /* Extract the version. */
234 version
= extract_unsigned_integer (ext_ldmbuf
->version
,
235 sizeof ext_ldmbuf
->version
,
239 /* We only handle version 0. */
243 /* Extract the number of segments. */
244 nsegs
= extract_unsigned_integer (ext_ldmbuf
->nsegs
,
245 sizeof ext_ldmbuf
->nsegs
,
251 /* Allocate space into which to put information extract from the
252 external loadsegs. I.e, allocate the internal loadsegs. */
253 int_ldmbuf_size
= (sizeof (struct int_elf32_dsbt_loadmap
)
254 + (nsegs
- 1) * sizeof (struct int_elf32_dsbt_loadseg
));
255 int_ldmbuf
= (struct int_elf32_dsbt_loadmap
*) xmalloc (int_ldmbuf_size
);
257 /* Place extracted information in internal structs. */
258 int_ldmbuf
->version
= version
;
259 int_ldmbuf
->nsegs
= nsegs
;
260 for (seg
= 0; seg
< nsegs
; seg
++)
262 int_ldmbuf
->segs
[seg
].addr
263 = extract_unsigned_integer (ext_ldmbuf
->segs
[seg
].addr
,
264 sizeof (ext_ldmbuf
->segs
[seg
].addr
),
266 int_ldmbuf
->segs
[seg
].p_vaddr
267 = extract_unsigned_integer (ext_ldmbuf
->segs
[seg
].p_vaddr
,
268 sizeof (ext_ldmbuf
->segs
[seg
].p_vaddr
),
270 int_ldmbuf
->segs
[seg
].p_memsz
271 = extract_unsigned_integer (ext_ldmbuf
->segs
[seg
].p_memsz
,
272 sizeof (ext_ldmbuf
->segs
[seg
].p_memsz
),
281 static struct dsbt_info
*get_dsbt_info (void);
283 /* Interrogate the Linux kernel to find out where the program was loaded.
284 There are two load maps; one for the executable and one for the
285 interpreter (only in the case of a dynamically linked executable). */
288 dsbt_get_initial_loadmaps (void)
291 struct dsbt_info
*info
= get_dsbt_info ();
293 if (0 >= target_read_alloc (¤t_target
, TARGET_OBJECT_FDPIC
,
296 info
->exec_loadmap
= NULL
;
297 error (_("Error reading DSBT exec loadmap"));
299 info
->exec_loadmap
= decode_loadmap (buf
);
300 if (solib_dsbt_debug
)
301 dsbt_print_loadmap (info
->exec_loadmap
);
303 if (0 >= target_read_alloc (¤t_target
, TARGET_OBJECT_FDPIC
,
306 info
->interp_loadmap
= NULL
;
307 error (_("Error reading DSBT interp loadmap"));
309 info
->interp_loadmap
= decode_loadmap (buf
);
310 if (solib_dsbt_debug
)
311 dsbt_print_loadmap (info
->interp_loadmap
);
314 /* Given address LDMADDR, fetch and decode the loadmap at that address.
315 Return NULL if there is a problem reading the target memory or if
316 there doesn't appear to be a loadmap at the given address. The
317 allocated space (representing the loadmap) returned by this
318 function may be freed via a single call to xfree. */
320 static struct int_elf32_dsbt_loadmap
*
321 fetch_loadmap (CORE_ADDR ldmaddr
)
323 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
324 struct ext_elf32_dsbt_loadmap ext_ldmbuf_partial
;
325 struct ext_elf32_dsbt_loadmap
*ext_ldmbuf
;
326 struct int_elf32_dsbt_loadmap
*int_ldmbuf
;
327 int ext_ldmbuf_size
, int_ldmbuf_size
;
328 int version
, seg
, nsegs
;
330 /* Fetch initial portion of the loadmap. */
331 if (target_read_memory (ldmaddr
, (gdb_byte
*) &ext_ldmbuf_partial
,
332 sizeof ext_ldmbuf_partial
))
334 /* Problem reading the target's memory. */
338 /* Extract the version. */
339 version
= extract_unsigned_integer (ext_ldmbuf_partial
.version
,
340 sizeof ext_ldmbuf_partial
.version
,
344 /* We only handle version 0. */
348 /* Extract the number of segments. */
349 nsegs
= extract_unsigned_integer (ext_ldmbuf_partial
.nsegs
,
350 sizeof ext_ldmbuf_partial
.nsegs
,
356 /* Allocate space for the complete (external) loadmap. */
357 ext_ldmbuf_size
= sizeof (struct ext_elf32_dsbt_loadmap
)
358 + (nsegs
- 1) * sizeof (struct ext_elf32_dsbt_loadseg
);
359 ext_ldmbuf
= (struct ext_elf32_dsbt_loadmap
*) xmalloc (ext_ldmbuf_size
);
361 /* Copy over the portion of the loadmap that's already been read. */
362 memcpy (ext_ldmbuf
, &ext_ldmbuf_partial
, sizeof ext_ldmbuf_partial
);
364 /* Read the rest of the loadmap from the target. */
365 if (target_read_memory (ldmaddr
+ sizeof ext_ldmbuf_partial
,
366 (gdb_byte
*) ext_ldmbuf
+ sizeof ext_ldmbuf_partial
,
367 ext_ldmbuf_size
- sizeof ext_ldmbuf_partial
))
369 /* Couldn't read rest of the loadmap. */
374 /* Allocate space into which to put information extract from the
375 external loadsegs. I.e, allocate the internal loadsegs. */
376 int_ldmbuf_size
= sizeof (struct int_elf32_dsbt_loadmap
)
377 + (nsegs
- 1) * sizeof (struct int_elf32_dsbt_loadseg
);
378 int_ldmbuf
= (struct int_elf32_dsbt_loadmap
*) xmalloc (int_ldmbuf_size
);
380 /* Place extracted information in internal structs. */
381 int_ldmbuf
->version
= version
;
382 int_ldmbuf
->nsegs
= nsegs
;
383 for (seg
= 0; seg
< nsegs
; seg
++)
385 int_ldmbuf
->segs
[seg
].addr
386 = extract_unsigned_integer (ext_ldmbuf
->segs
[seg
].addr
,
387 sizeof (ext_ldmbuf
->segs
[seg
].addr
),
389 int_ldmbuf
->segs
[seg
].p_vaddr
390 = extract_unsigned_integer (ext_ldmbuf
->segs
[seg
].p_vaddr
,
391 sizeof (ext_ldmbuf
->segs
[seg
].p_vaddr
),
393 int_ldmbuf
->segs
[seg
].p_memsz
394 = extract_unsigned_integer (ext_ldmbuf
->segs
[seg
].p_memsz
,
395 sizeof (ext_ldmbuf
->segs
[seg
].p_memsz
),
403 static void dsbt_relocate_main_executable (void);
404 static int enable_break (void);
406 /* Scan for DYNTAG in .dynamic section of ABFD. If DYNTAG is found 1 is
407 returned and the corresponding PTR is set. */
410 scan_dyntag (int dyntag
, bfd
*abfd
, CORE_ADDR
*ptr
)
412 int arch_size
, step
, sect_size
;
414 CORE_ADDR dyn_ptr
, dyn_addr
;
415 gdb_byte
*bufend
, *bufstart
, *buf
;
416 Elf32_External_Dyn
*x_dynp_32
;
417 Elf64_External_Dyn
*x_dynp_64
;
418 struct bfd_section
*sect
;
419 struct target_section
*target_section
;
424 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
427 arch_size
= bfd_get_arch_size (abfd
);
431 /* Find the start address of the .dynamic section. */
432 sect
= bfd_get_section_by_name (abfd
, ".dynamic");
436 for (target_section
= current_target_sections
->sections
;
437 target_section
< current_target_sections
->sections_end
;
439 if (sect
== target_section
->the_bfd_section
)
441 if (target_section
< current_target_sections
->sections_end
)
442 dyn_addr
= target_section
->addr
;
445 /* ABFD may come from OBJFILE acting only as a symbol file without being
446 loaded into the target (see add_symbol_file_command). This case is
447 such fallback to the file VMA address without the possibility of
448 having the section relocated to its actual in-memory address. */
450 dyn_addr
= bfd_section_vma (abfd
, sect
);
453 /* Read in .dynamic from the BFD. We will get the actual value
454 from memory later. */
455 sect_size
= bfd_section_size (abfd
, sect
);
456 buf
= bufstart
= (gdb_byte
*) alloca (sect_size
);
457 if (!bfd_get_section_contents (abfd
, sect
,
461 /* Iterate over BUF and scan for DYNTAG. If found, set PTR and return. */
462 step
= (arch_size
== 32) ? sizeof (Elf32_External_Dyn
)
463 : sizeof (Elf64_External_Dyn
);
464 for (bufend
= buf
+ sect_size
;
470 x_dynp_32
= (Elf32_External_Dyn
*) buf
;
471 dyn_tag
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_dynp_32
->d_tag
);
472 dyn_ptr
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_dynp_32
->d_un
.d_ptr
);
476 x_dynp_64
= (Elf64_External_Dyn
*) buf
;
477 dyn_tag
= bfd_h_get_64 (abfd
, (bfd_byte
*) x_dynp_64
->d_tag
);
478 dyn_ptr
= bfd_h_get_64 (abfd
, (bfd_byte
*) x_dynp_64
->d_un
.d_ptr
);
480 if (dyn_tag
== DT_NULL
)
482 if (dyn_tag
== dyntag
)
484 /* If requested, try to read the runtime value of this .dynamic
488 struct type
*ptr_type
;
492 ptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
493 ptr_addr
= dyn_addr
+ (buf
- bufstart
) + arch_size
/ 8;
494 if (target_read_memory (ptr_addr
, ptr_buf
, arch_size
/ 8) == 0)
495 dyn_ptr
= extract_typed_address (ptr_buf
, ptr_type
);
505 /* If no open symbol file, attempt to locate and open the main symbol
508 If FROM_TTYP dereferences to a non-zero integer, allow messages to
509 be printed. This parameter is a pointer rather than an int because
510 open_symbol_file_object is called via catch_errors and
511 catch_errors requires a pointer argument. */
514 open_symbol_file_object (void *from_ttyp
)
520 /* Given a loadmap and an address, return the displacement needed
521 to relocate the address. */
524 displacement_from_map (struct int_elf32_dsbt_loadmap
*map
,
529 for (seg
= 0; seg
< map
->nsegs
; seg
++)
530 if (map
->segs
[seg
].p_vaddr
<= addr
531 && addr
< map
->segs
[seg
].p_vaddr
+ map
->segs
[seg
].p_memsz
)
532 return map
->segs
[seg
].addr
- map
->segs
[seg
].p_vaddr
;
537 /* Return the address from which the link map chain may be found. On
538 DSBT, a pointer to the start of the link map will be located at the
539 word found at base of GOT + GOT_MODULE_OFFSET.
541 The base of GOT may be found in a number of ways. Assuming that the
542 main executable has already been relocated,
543 1 The easiest way to find this value is to look up the address of
544 _GLOBAL_OFFSET_TABLE_.
545 2 The other way is to look for tag DT_PLTGOT, which contains the virtual
546 address of Global Offset Table. .*/
551 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
552 struct bound_minimal_symbol got_sym
;
554 gdb_byte buf
[TIC6X_PTR_SIZE
];
555 struct dsbt_info
*info
= get_dsbt_info ();
557 /* One of our assumptions is that the main executable has been relocated.
558 Bail out if this has not happened. (Note that post_create_inferior
559 in infcmd.c will call solib_add prior to solib_create_inferior_hook.
560 If we allow this to happen, lm_base_cache will be initialized with
562 if (info
->main_executable_lm_info
== 0)
565 /* If we already have a cached value, return it. */
566 if (info
->lm_base_cache
)
567 return info
->lm_base_cache
;
569 got_sym
= lookup_minimal_symbol ("_GLOBAL_OFFSET_TABLE_", NULL
,
572 if (got_sym
.minsym
!= 0)
574 addr
= BMSYMBOL_VALUE_ADDRESS (got_sym
);
575 if (solib_dsbt_debug
)
576 fprintf_unfiltered (gdb_stdlog
,
577 "lm_base: get addr %x by _GLOBAL_OFFSET_TABLE_.\n",
578 (unsigned int) addr
);
580 else if (scan_dyntag (DT_PLTGOT
, exec_bfd
, &addr
))
582 struct int_elf32_dsbt_loadmap
*ldm
;
584 dsbt_get_initial_loadmaps ();
585 ldm
= info
->exec_loadmap
;
586 addr
+= displacement_from_map (ldm
, addr
);
587 if (solib_dsbt_debug
)
588 fprintf_unfiltered (gdb_stdlog
,
589 "lm_base: get addr %x by DT_PLTGOT.\n",
590 (unsigned int) addr
);
594 if (solib_dsbt_debug
)
595 fprintf_unfiltered (gdb_stdlog
,
596 "lm_base: _GLOBAL_OFFSET_TABLE_ not found.\n");
599 addr
+= GOT_MODULE_OFFSET
;
601 if (solib_dsbt_debug
)
602 fprintf_unfiltered (gdb_stdlog
,
603 "lm_base: _GLOBAL_OFFSET_TABLE_ + %d = %s\n",
604 GOT_MODULE_OFFSET
, hex_string_custom (addr
, 8));
606 if (target_read_memory (addr
, buf
, sizeof buf
) != 0)
608 info
->lm_base_cache
= extract_unsigned_integer (buf
, sizeof buf
, byte_order
);
610 if (solib_dsbt_debug
)
611 fprintf_unfiltered (gdb_stdlog
,
612 "lm_base: lm_base_cache = %s\n",
613 hex_string_custom (info
->lm_base_cache
, 8));
615 return info
->lm_base_cache
;
619 /* Build a list of `struct so_list' objects describing the shared
620 objects currently loaded in the inferior. This list does not
621 include an entry for the main executable file.
623 Note that we only gather information directly available from the
624 inferior --- we don't examine any of the shared library files
625 themselves. The declaration of `struct so_list' says which fields
626 we provide values for. */
628 static struct so_list
*
629 dsbt_current_sos (void)
631 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
633 struct so_list
*sos_head
= NULL
;
634 struct so_list
**sos_next_ptr
= &sos_head
;
635 struct dsbt_info
*info
= get_dsbt_info ();
637 /* Make sure that the main executable has been relocated. This is
638 required in order to find the address of the global offset table,
639 which in turn is used to find the link map info. (See lm_base
642 Note that the relocation of the main executable is also performed
643 by solib_create_inferior_hook, however, in the case of core
644 files, this hook is called too late in order to be of benefit to
645 solib_add. solib_add eventually calls this function,
646 dsbt_current_sos, and also precedes the call to
647 solib_create_inferior_hook. (See post_create_inferior in
649 if (info
->main_executable_lm_info
== 0 && core_bfd
!= NULL
)
650 dsbt_relocate_main_executable ();
652 /* Locate the address of the first link map struct. */
653 lm_addr
= lm_base ();
655 /* We have at least one link map entry. Fetch the the lot of them,
656 building the solist chain. */
659 struct ext_link_map lm_buf
;
660 ext_Elf32_Word indexword
;
665 if (solib_dsbt_debug
)
666 fprintf_unfiltered (gdb_stdlog
,
667 "current_sos: reading link_map entry at %s\n",
668 hex_string_custom (lm_addr
, 8));
670 ret
= target_read_memory (lm_addr
, (gdb_byte
*) &lm_buf
, sizeof (lm_buf
));
673 warning (_("dsbt_current_sos: Unable to read link map entry."
674 " Shared object chain may be incomplete."));
678 /* Fetch the load map address. */
679 map_addr
= extract_unsigned_integer (lm_buf
.l_addr
.map
,
680 sizeof lm_buf
.l_addr
.map
,
683 ret
= target_read_memory (map_addr
+ 12, (gdb_byte
*) &indexword
,
687 warning (_("dsbt_current_sos: Unable to read dsbt index."
688 " Shared object chain may be incomplete."));
691 dsbt_index
= extract_unsigned_integer (indexword
, sizeof indexword
,
694 /* If the DSBT index is zero, then we're looking at the entry
695 for the main executable. By convention, we don't include
696 this in the list of shared objects. */
701 struct int_elf32_dsbt_loadmap
*loadmap
;
705 loadmap
= fetch_loadmap (map_addr
);
708 warning (_("dsbt_current_sos: Unable to fetch load map."
709 " Shared object chain may be incomplete."));
713 sop
= XCNEW (struct so_list
);
714 sop
->lm_info
= XCNEW (struct lm_info
);
715 sop
->lm_info
->map
= loadmap
;
716 /* Fetch the name. */
717 addr
= extract_unsigned_integer (lm_buf
.l_name
,
718 sizeof (lm_buf
.l_name
),
720 target_read_string (addr
, &name_buf
, SO_NAME_MAX_PATH_SIZE
- 1,
724 warning (_("Can't read pathname for link map entry: %s."),
725 safe_strerror (errcode
));
728 if (solib_dsbt_debug
)
729 fprintf_unfiltered (gdb_stdlog
, "current_sos: name = %s\n",
732 strncpy (sop
->so_name
, name_buf
, SO_NAME_MAX_PATH_SIZE
- 1);
733 sop
->so_name
[SO_NAME_MAX_PATH_SIZE
- 1] = '\0';
735 strcpy (sop
->so_original_name
, sop
->so_name
);
739 sos_next_ptr
= &sop
->next
;
743 info
->main_lm_addr
= lm_addr
;
746 lm_addr
= extract_unsigned_integer (lm_buf
.l_next
,
747 sizeof (lm_buf
.l_next
), byte_order
);
753 /* Return 1 if PC lies in the dynamic symbol resolution code of the
757 dsbt_in_dynsym_resolve_code (CORE_ADDR pc
)
759 struct dsbt_info
*info
= get_dsbt_info ();
761 return ((pc
>= info
->interp_text_sect_low
&& pc
< info
->interp_text_sect_high
)
762 || (pc
>= info
->interp_plt_sect_low
&& pc
< info
->interp_plt_sect_high
)
763 || in_plt_section (pc
));
766 /* Print a warning about being unable to set the dynamic linker
770 enable_break_failure_warning (void)
772 warning (_("Unable to find dynamic linker breakpoint function.\n"
773 "GDB will be unable to debug shared library initializers\n"
774 "and track explicitly loaded dynamic code."));
777 /* Helper function for gdb_bfd_lookup_symbol. */
780 cmp_name (const asymbol
*sym
, const void *data
)
782 return (strcmp (sym
->name
, (const char *) data
) == 0);
785 /* The dynamic linkers has, as part of its debugger interface, support
786 for arranging for the inferior to hit a breakpoint after mapping in
787 the shared libraries. This function enables that breakpoint.
789 On the TIC6X, using the shared library (DSBT), GDB can try to place
790 a breakpoint on '_dl_debug_state' to monitor the shared library
796 asection
*interp_sect
;
797 struct dsbt_info
*info
;
799 if (exec_bfd
== NULL
)
802 if (!target_has_execution
)
805 info
= get_dsbt_info ();
807 info
->interp_text_sect_low
= 0;
808 info
->interp_text_sect_high
= 0;
809 info
->interp_plt_sect_low
= 0;
810 info
->interp_plt_sect_high
= 0;
812 /* Find the .interp section; if not found, warn the user and drop
813 into the old breakpoint at symbol code. */
814 interp_sect
= bfd_get_section_by_name (exec_bfd
, ".interp");
817 unsigned int interp_sect_size
;
820 struct int_elf32_dsbt_loadmap
*ldm
;
823 /* Read the contents of the .interp section into a local buffer;
824 the contents specify the dynamic linker this program uses. */
825 interp_sect_size
= bfd_section_size (exec_bfd
, interp_sect
);
826 buf
= (char *) alloca (interp_sect_size
);
827 bfd_get_section_contents (exec_bfd
, interp_sect
,
828 buf
, 0, interp_sect_size
);
830 /* Now we need to figure out where the dynamic linker was
831 loaded so that we can load its symbols and place a breakpoint
832 in the dynamic linker itself. */
834 gdb_bfd_ref_ptr tmp_bfd
;
837 tmp_bfd
= solib_bfd_open (buf
);
839 CATCH (ex
, RETURN_MASK_ALL
)
846 enable_break_failure_warning ();
850 dsbt_get_initial_loadmaps ();
851 ldm
= info
->interp_loadmap
;
853 /* Record the relocated start and end address of the dynamic linker
854 text and plt section for dsbt_in_dynsym_resolve_code. */
855 interp_sect
= bfd_get_section_by_name (tmp_bfd
.get (), ".text");
858 info
->interp_text_sect_low
859 = bfd_section_vma (tmp_bfd
.get (), interp_sect
);
860 info
->interp_text_sect_low
861 += displacement_from_map (ldm
, info
->interp_text_sect_low
);
862 info
->interp_text_sect_high
863 = info
->interp_text_sect_low
864 + bfd_section_size (tmp_bfd
.get (), interp_sect
);
866 interp_sect
= bfd_get_section_by_name (tmp_bfd
.get (), ".plt");
869 info
->interp_plt_sect_low
=
870 bfd_section_vma (tmp_bfd
.get (), interp_sect
);
871 info
->interp_plt_sect_low
872 += displacement_from_map (ldm
, info
->interp_plt_sect_low
);
873 info
->interp_plt_sect_high
=
874 info
->interp_plt_sect_low
+ bfd_section_size (tmp_bfd
.get (),
878 addr
= gdb_bfd_lookup_symbol (tmp_bfd
.get (), cmp_name
,
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
);
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));
893 /* Now (finally!) create the solib breakpoint. */
894 create_solib_event_breakpoint (target_gdbarch (), addr
);
900 if (solib_dsbt_debug
)
901 fprintf_unfiltered (gdb_stdlog
,
902 "enable_break: _dl_debug_state is not found\n");
906 /* We're done with the loadmap. */
912 /* Tell the user we couldn't set a dynamic linker breakpoint. */
913 enable_break_failure_warning ();
915 /* Failure return. */
920 dsbt_relocate_main_executable (void)
922 struct int_elf32_dsbt_loadmap
*ldm
;
923 struct cleanup
*old_chain
;
924 struct section_offsets
*new_offsets
;
926 struct obj_section
*osect
;
927 struct dsbt_info
*info
= get_dsbt_info ();
929 dsbt_get_initial_loadmaps ();
930 ldm
= info
->exec_loadmap
;
932 xfree (info
->main_executable_lm_info
);
933 info
->main_executable_lm_info
= XCNEW (struct lm_info
);
934 info
->main_executable_lm_info
->map
= ldm
;
936 new_offsets
= XCNEWVEC (struct section_offsets
,
937 symfile_objfile
->num_sections
);
938 old_chain
= make_cleanup (xfree
, new_offsets
);
941 ALL_OBJFILE_OSECTIONS (symfile_objfile
, osect
)
943 CORE_ADDR orig_addr
, addr
, offset
;
947 osect_idx
= osect
- symfile_objfile
->sections
;
949 /* Current address of section. */
950 addr
= obj_section_addr (osect
);
951 /* Offset from where this section started. */
952 offset
= ANOFFSET (symfile_objfile
->section_offsets
, osect_idx
);
953 /* Original address prior to any past relocations. */
954 orig_addr
= addr
- offset
;
956 for (seg
= 0; seg
< ldm
->nsegs
; seg
++)
958 if (ldm
->segs
[seg
].p_vaddr
<= orig_addr
959 && orig_addr
< ldm
->segs
[seg
].p_vaddr
+ ldm
->segs
[seg
].p_memsz
)
961 new_offsets
->offsets
[osect_idx
]
962 = ldm
->segs
[seg
].addr
- ldm
->segs
[seg
].p_vaddr
;
964 if (new_offsets
->offsets
[osect_idx
] != offset
)
972 objfile_relocate (symfile_objfile
, new_offsets
);
974 do_cleanups (old_chain
);
976 /* Now that symfile_objfile has been relocated, we can compute the
977 GOT value and stash it away. */
980 /* When gdb starts up the inferior, it nurses it along (through the
981 shell) until it is ready to execute it's first instruction. At this
982 point, this function gets called via solib_create_inferior_hook.
984 For the DSBT shared library, the main executable needs to be relocated.
985 The shared library breakpoints also need to be enabled. */
988 dsbt_solib_create_inferior_hook (int from_tty
)
990 /* Relocate main executable. */
991 dsbt_relocate_main_executable ();
993 /* Enable shared library breakpoints. */
994 if (!enable_break ())
996 warning (_("shared library handler failed to enable breakpoint"));
1002 dsbt_clear_solib (void)
1004 struct dsbt_info
*info
= get_dsbt_info ();
1006 info
->lm_base_cache
= 0;
1007 info
->main_lm_addr
= 0;
1008 if (info
->main_executable_lm_info
!= 0)
1010 xfree (info
->main_executable_lm_info
->map
);
1011 xfree (info
->main_executable_lm_info
);
1012 info
->main_executable_lm_info
= 0;
1017 dsbt_free_so (struct so_list
*so
)
1019 xfree (so
->lm_info
->map
);
1020 xfree (so
->lm_info
);
1024 dsbt_relocate_section_addresses (struct so_list
*so
,
1025 struct target_section
*sec
)
1028 struct int_elf32_dsbt_loadmap
*map
;
1030 map
= so
->lm_info
->map
;
1032 for (seg
= 0; seg
< map
->nsegs
; seg
++)
1034 if (map
->segs
[seg
].p_vaddr
<= sec
->addr
1035 && sec
->addr
< map
->segs
[seg
].p_vaddr
+ map
->segs
[seg
].p_memsz
)
1037 CORE_ADDR displ
= map
->segs
[seg
].addr
- map
->segs
[seg
].p_vaddr
;
1040 sec
->endaddr
+= displ
;
1046 show_dsbt_debug (struct ui_file
*file
, int from_tty
,
1047 struct cmd_list_element
*c
, const char *value
)
1049 fprintf_filtered (file
, _("solib-dsbt debugging is %s.\n"), value
);
1052 struct target_so_ops dsbt_so_ops
;
1054 /* Provide a prototype to silence -Wmissing-prototypes. */
1055 extern initialize_file_ftype _initialize_dsbt_solib
;
1058 _initialize_dsbt_solib (void)
1060 solib_dsbt_pspace_data
1061 = register_program_space_data_with_cleanup (NULL
, dsbt_pspace_data_cleanup
);
1063 dsbt_so_ops
.relocate_section_addresses
= dsbt_relocate_section_addresses
;
1064 dsbt_so_ops
.free_so
= dsbt_free_so
;
1065 dsbt_so_ops
.clear_solib
= dsbt_clear_solib
;
1066 dsbt_so_ops
.solib_create_inferior_hook
= dsbt_solib_create_inferior_hook
;
1067 dsbt_so_ops
.current_sos
= dsbt_current_sos
;
1068 dsbt_so_ops
.open_symbol_file_object
= open_symbol_file_object
;
1069 dsbt_so_ops
.in_dynsym_resolve_code
= dsbt_in_dynsym_resolve_code
;
1070 dsbt_so_ops
.bfd_open
= solib_bfd_open
;
1072 /* Debug this file's internals. */
1073 add_setshow_zuinteger_cmd ("solib-dsbt", class_maintenance
,
1074 &solib_dsbt_debug
, _("\
1075 Set internal debugging of shared library code for DSBT ELF."), _("\
1076 Show internal debugging of shared library code for DSBT ELF."), _("\
1077 When non-zero, DSBT solib specific internal debugging is enabled."),
1080 &setdebuglist
, &showdebuglist
);