1 /* Handle TIC6X (DSBT) shared libraries for GDB, the GNU Debugger.
2 Copyright (C) 2010-2021 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 */
126 struct lm_info_dsbt
: public lm_info_base
133 /* The loadmap, digested into an easier to use form. */
134 int_elf32_dsbt_loadmap
*map
= NULL
;
137 /* Per pspace dsbt specific data. */
141 /* The load map, got value, etc. are not available from the chain
142 of loaded shared objects. ``main_executable_lm_info'' provides
143 a way to get at this information so that it doesn't need to be
144 frequently recomputed. Initialized by dsbt_relocate_main_executable. */
145 struct lm_info_dsbt
*main_executable_lm_info
= nullptr;
147 /* Load maps for the main executable and the interpreter. These are obtained
148 from ptrace. They are the starting point for getting into the program,
149 and are required to find the solib list with the individual load maps for
151 struct int_elf32_dsbt_loadmap
*exec_loadmap
= nullptr;
152 struct int_elf32_dsbt_loadmap
*interp_loadmap
= nullptr;
154 /* Cached value for lm_base, below. */
155 CORE_ADDR lm_base_cache
= 0;
157 /* Link map address for main module. */
158 CORE_ADDR main_lm_addr
= 0;
160 CORE_ADDR interp_text_sect_low
= 0;
161 CORE_ADDR interp_text_sect_high
= 0;
162 CORE_ADDR interp_plt_sect_low
= 0;
163 CORE_ADDR interp_plt_sect_high
= 0;
166 /* Per-program-space data key. */
167 static program_space_key
<dsbt_info
> solib_dsbt_pspace_data
;
169 /* Get the current dsbt data. If none is found yet, add it now. This
170 function always returns a valid object. */
172 static struct dsbt_info
*
175 struct dsbt_info
*info
;
177 info
= solib_dsbt_pspace_data
.get (current_program_space
);
181 return solib_dsbt_pspace_data
.emplace (current_program_space
);
186 dsbt_print_loadmap (struct int_elf32_dsbt_loadmap
*map
)
191 printf_filtered ("(null)\n");
192 else if (map
->version
!= 0)
193 printf_filtered (_("Unsupported map version: %d\n"), map
->version
);
196 printf_filtered ("version %d\n", map
->version
);
198 for (i
= 0; i
< map
->nsegs
; i
++)
199 printf_filtered ("%s:%s -> %s:%s\n",
200 print_core_address (target_gdbarch (),
201 map
->segs
[i
].p_vaddr
),
202 print_core_address (target_gdbarch (),
204 + map
->segs
[i
].p_memsz
),
205 print_core_address (target_gdbarch (), map
->segs
[i
].addr
),
206 print_core_address (target_gdbarch (), map
->segs
[i
].addr
207 + map
->segs
[i
].p_memsz
));
211 /* Decode int_elf32_dsbt_loadmap from BUF. */
213 static struct int_elf32_dsbt_loadmap
*
214 decode_loadmap (const gdb_byte
*buf
)
216 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
217 const struct ext_elf32_dsbt_loadmap
*ext_ldmbuf
;
218 struct int_elf32_dsbt_loadmap
*int_ldmbuf
;
220 int version
, seg
, nsegs
;
223 ext_ldmbuf
= (struct ext_elf32_dsbt_loadmap
*) buf
;
225 /* Extract the version. */
226 version
= extract_unsigned_integer (ext_ldmbuf
->version
,
227 sizeof ext_ldmbuf
->version
,
231 /* We only handle version 0. */
235 /* Extract the number of segments. */
236 nsegs
= extract_unsigned_integer (ext_ldmbuf
->nsegs
,
237 sizeof ext_ldmbuf
->nsegs
,
243 /* Allocate space into which to put information extract from the
244 external loadsegs. I.e, allocate the internal loadsegs. */
245 int_ldmbuf_size
= (sizeof (struct int_elf32_dsbt_loadmap
)
246 + (nsegs
- 1) * sizeof (struct int_elf32_dsbt_loadseg
));
247 int_ldmbuf
= (struct int_elf32_dsbt_loadmap
*) xmalloc (int_ldmbuf_size
);
249 /* Place extracted information in internal structs. */
250 int_ldmbuf
->version
= version
;
251 int_ldmbuf
->nsegs
= nsegs
;
252 for (seg
= 0; seg
< nsegs
; seg
++)
254 int_ldmbuf
->segs
[seg
].addr
255 = extract_unsigned_integer (ext_ldmbuf
->segs
[seg
].addr
,
256 sizeof (ext_ldmbuf
->segs
[seg
].addr
),
258 int_ldmbuf
->segs
[seg
].p_vaddr
259 = extract_unsigned_integer (ext_ldmbuf
->segs
[seg
].p_vaddr
,
260 sizeof (ext_ldmbuf
->segs
[seg
].p_vaddr
),
262 int_ldmbuf
->segs
[seg
].p_memsz
263 = extract_unsigned_integer (ext_ldmbuf
->segs
[seg
].p_memsz
,
264 sizeof (ext_ldmbuf
->segs
[seg
].p_memsz
),
272 static struct dsbt_info
*get_dsbt_info (void);
274 /* Interrogate the Linux kernel to find out where the program was loaded.
275 There are two load maps; one for the executable and one for the
276 interpreter (only in the case of a dynamically linked executable). */
279 dsbt_get_initial_loadmaps (void)
281 struct dsbt_info
*info
= get_dsbt_info ();
282 gdb::optional
<gdb::byte_vector
> buf
283 = target_read_alloc (current_top_target (), TARGET_OBJECT_FDPIC
, "exec");
285 if (!buf
|| buf
->empty ())
287 info
->exec_loadmap
= NULL
;
288 error (_("Error reading DSBT exec loadmap"));
290 info
->exec_loadmap
= decode_loadmap (buf
->data ());
291 if (solib_dsbt_debug
)
292 dsbt_print_loadmap (info
->exec_loadmap
);
294 buf
= target_read_alloc (current_top_target (), TARGET_OBJECT_FDPIC
, "exec");
295 if (!buf
|| buf
->empty ())
297 info
->interp_loadmap
= NULL
;
298 error (_("Error reading DSBT interp loadmap"));
300 info
->interp_loadmap
= decode_loadmap (buf
->data ());
301 if (solib_dsbt_debug
)
302 dsbt_print_loadmap (info
->interp_loadmap
);
305 /* Given address LDMADDR, fetch and decode the loadmap at that address.
306 Return NULL if there is a problem reading the target memory or if
307 there doesn't appear to be a loadmap at the given address. The
308 allocated space (representing the loadmap) returned by this
309 function may be freed via a single call to xfree. */
311 static struct int_elf32_dsbt_loadmap
*
312 fetch_loadmap (CORE_ADDR ldmaddr
)
314 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
315 struct ext_elf32_dsbt_loadmap ext_ldmbuf_partial
;
316 struct ext_elf32_dsbt_loadmap
*ext_ldmbuf
;
317 struct int_elf32_dsbt_loadmap
*int_ldmbuf
;
318 int ext_ldmbuf_size
, int_ldmbuf_size
;
319 int version
, seg
, nsegs
;
321 /* Fetch initial portion of the loadmap. */
322 if (target_read_memory (ldmaddr
, (gdb_byte
*) &ext_ldmbuf_partial
,
323 sizeof ext_ldmbuf_partial
))
325 /* Problem reading the target's memory. */
329 /* Extract the version. */
330 version
= extract_unsigned_integer (ext_ldmbuf_partial
.version
,
331 sizeof ext_ldmbuf_partial
.version
,
335 /* We only handle version 0. */
339 /* Extract the number of segments. */
340 nsegs
= extract_unsigned_integer (ext_ldmbuf_partial
.nsegs
,
341 sizeof ext_ldmbuf_partial
.nsegs
,
347 /* Allocate space for the complete (external) loadmap. */
348 ext_ldmbuf_size
= sizeof (struct ext_elf32_dsbt_loadmap
)
349 + (nsegs
- 1) * sizeof (struct ext_elf32_dsbt_loadseg
);
350 ext_ldmbuf
= (struct ext_elf32_dsbt_loadmap
*) xmalloc (ext_ldmbuf_size
);
352 /* Copy over the portion of the loadmap that's already been read. */
353 memcpy (ext_ldmbuf
, &ext_ldmbuf_partial
, sizeof ext_ldmbuf_partial
);
355 /* Read the rest of the loadmap from the target. */
356 if (target_read_memory (ldmaddr
+ sizeof ext_ldmbuf_partial
,
357 (gdb_byte
*) ext_ldmbuf
+ sizeof ext_ldmbuf_partial
,
358 ext_ldmbuf_size
- sizeof ext_ldmbuf_partial
))
360 /* Couldn't read rest of the loadmap. */
365 /* Allocate space into which to put information extract from the
366 external loadsegs. I.e, allocate the internal loadsegs. */
367 int_ldmbuf_size
= sizeof (struct int_elf32_dsbt_loadmap
)
368 + (nsegs
- 1) * sizeof (struct int_elf32_dsbt_loadseg
);
369 int_ldmbuf
= (struct int_elf32_dsbt_loadmap
*) xmalloc (int_ldmbuf_size
);
371 /* Place extracted information in internal structs. */
372 int_ldmbuf
->version
= version
;
373 int_ldmbuf
->nsegs
= nsegs
;
374 for (seg
= 0; seg
< nsegs
; seg
++)
376 int_ldmbuf
->segs
[seg
].addr
377 = extract_unsigned_integer (ext_ldmbuf
->segs
[seg
].addr
,
378 sizeof (ext_ldmbuf
->segs
[seg
].addr
),
380 int_ldmbuf
->segs
[seg
].p_vaddr
381 = extract_unsigned_integer (ext_ldmbuf
->segs
[seg
].p_vaddr
,
382 sizeof (ext_ldmbuf
->segs
[seg
].p_vaddr
),
384 int_ldmbuf
->segs
[seg
].p_memsz
385 = extract_unsigned_integer (ext_ldmbuf
->segs
[seg
].p_memsz
,
386 sizeof (ext_ldmbuf
->segs
[seg
].p_memsz
),
394 static void dsbt_relocate_main_executable (void);
395 static int enable_break (void);
397 /* Scan for DYNTAG in .dynamic section of ABFD. If DYNTAG is found 1 is
398 returned and the corresponding PTR is set. */
401 scan_dyntag (int dyntag
, bfd
*abfd
, CORE_ADDR
*ptr
)
403 int arch_size
, step
, sect_size
;
405 CORE_ADDR dyn_ptr
, dyn_addr
;
406 gdb_byte
*bufend
, *bufstart
, *buf
;
407 Elf32_External_Dyn
*x_dynp_32
;
408 Elf64_External_Dyn
*x_dynp_64
;
409 struct bfd_section
*sect
;
414 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
417 arch_size
= bfd_get_arch_size (abfd
);
421 /* Find the start address of the .dynamic section. */
422 sect
= bfd_get_section_by_name (abfd
, ".dynamic");
427 for (const target_section
&target_section
428 : current_program_space
->target_sections ())
429 if (sect
== target_section
.the_bfd_section
)
431 dyn_addr
= target_section
.addr
;
437 /* ABFD may come from OBJFILE acting only as a symbol file without being
438 loaded into the target (see add_symbol_file_command). This case is
439 such fallback to the file VMA address without the possibility of
440 having the section relocated to its actual in-memory address. */
442 dyn_addr
= bfd_section_vma (sect
);
445 /* Read in .dynamic from the BFD. We will get the actual value
446 from memory later. */
447 sect_size
= bfd_section_size (sect
);
448 buf
= bufstart
= (gdb_byte
*) alloca (sect_size
);
449 if (!bfd_get_section_contents (abfd
, sect
,
453 /* Iterate over BUF and scan for DYNTAG. If found, set PTR and return. */
454 step
= (arch_size
== 32) ? sizeof (Elf32_External_Dyn
)
455 : sizeof (Elf64_External_Dyn
);
456 for (bufend
= buf
+ sect_size
;
462 x_dynp_32
= (Elf32_External_Dyn
*) buf
;
463 dyn_tag
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_dynp_32
->d_tag
);
464 dyn_ptr
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_dynp_32
->d_un
.d_ptr
);
468 x_dynp_64
= (Elf64_External_Dyn
*) buf
;
469 dyn_tag
= bfd_h_get_64 (abfd
, (bfd_byte
*) x_dynp_64
->d_tag
);
470 dyn_ptr
= bfd_h_get_64 (abfd
, (bfd_byte
*) x_dynp_64
->d_un
.d_ptr
);
472 if (dyn_tag
== DT_NULL
)
474 if (dyn_tag
== dyntag
)
476 /* If requested, try to read the runtime value of this .dynamic
480 struct type
*ptr_type
;
484 ptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
485 ptr_addr
= dyn_addr
+ (buf
- bufstart
) + arch_size
/ 8;
486 if (target_read_memory (ptr_addr
, ptr_buf
, arch_size
/ 8) == 0)
487 dyn_ptr
= extract_typed_address (ptr_buf
, ptr_type
);
500 open_symbol_file_object (int from_tty
)
506 /* Given a loadmap and an address, return the displacement needed
507 to relocate the address. */
510 displacement_from_map (struct int_elf32_dsbt_loadmap
*map
,
515 for (seg
= 0; seg
< map
->nsegs
; seg
++)
516 if (map
->segs
[seg
].p_vaddr
<= addr
517 && addr
< map
->segs
[seg
].p_vaddr
+ map
->segs
[seg
].p_memsz
)
518 return map
->segs
[seg
].addr
- map
->segs
[seg
].p_vaddr
;
523 /* Return the address from which the link map chain may be found. On
524 DSBT, a pointer to the start of the link map will be located at the
525 word found at base of GOT + GOT_MODULE_OFFSET.
527 The base of GOT may be found in a number of ways. Assuming that the
528 main executable has already been relocated,
529 1 The easiest way to find this value is to look up the address of
530 _GLOBAL_OFFSET_TABLE_.
531 2 The other way is to look for tag DT_PLTGOT, which contains the virtual
532 address of Global Offset Table. .*/
537 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
538 struct bound_minimal_symbol got_sym
;
540 gdb_byte buf
[TIC6X_PTR_SIZE
];
541 struct dsbt_info
*info
= get_dsbt_info ();
543 /* One of our assumptions is that the main executable has been relocated.
544 Bail out if this has not happened. (Note that post_create_inferior
545 in infcmd.c will call solib_add prior to solib_create_inferior_hook.
546 If we allow this to happen, lm_base_cache will be initialized with
548 if (info
->main_executable_lm_info
== 0)
551 /* If we already have a cached value, return it. */
552 if (info
->lm_base_cache
)
553 return info
->lm_base_cache
;
555 got_sym
= lookup_minimal_symbol ("_GLOBAL_OFFSET_TABLE_", NULL
,
556 current_program_space
->symfile_object_file
);
558 if (got_sym
.minsym
!= 0)
560 addr
= BMSYMBOL_VALUE_ADDRESS (got_sym
);
561 if (solib_dsbt_debug
)
562 fprintf_unfiltered (gdb_stdlog
,
563 "lm_base: get addr %x by _GLOBAL_OFFSET_TABLE_.\n",
564 (unsigned int) addr
);
566 else if (scan_dyntag (DT_PLTGOT
, current_program_space
->exec_bfd (), &addr
))
568 struct int_elf32_dsbt_loadmap
*ldm
;
570 dsbt_get_initial_loadmaps ();
571 ldm
= info
->exec_loadmap
;
572 addr
+= displacement_from_map (ldm
, addr
);
573 if (solib_dsbt_debug
)
574 fprintf_unfiltered (gdb_stdlog
,
575 "lm_base: get addr %x by DT_PLTGOT.\n",
576 (unsigned int) addr
);
580 if (solib_dsbt_debug
)
581 fprintf_unfiltered (gdb_stdlog
,
582 "lm_base: _GLOBAL_OFFSET_TABLE_ not found.\n");
585 addr
+= GOT_MODULE_OFFSET
;
587 if (solib_dsbt_debug
)
588 fprintf_unfiltered (gdb_stdlog
,
589 "lm_base: _GLOBAL_OFFSET_TABLE_ + %d = %s\n",
590 GOT_MODULE_OFFSET
, hex_string_custom (addr
, 8));
592 if (target_read_memory (addr
, buf
, sizeof buf
) != 0)
594 info
->lm_base_cache
= extract_unsigned_integer (buf
, sizeof buf
, byte_order
);
596 if (solib_dsbt_debug
)
597 fprintf_unfiltered (gdb_stdlog
,
598 "lm_base: lm_base_cache = %s\n",
599 hex_string_custom (info
->lm_base_cache
, 8));
601 return info
->lm_base_cache
;
605 /* Build a list of `struct so_list' objects describing the shared
606 objects currently loaded in the inferior. This list does not
607 include an entry for the main executable file.
609 Note that we only gather information directly available from the
610 inferior --- we don't examine any of the shared library files
611 themselves. The declaration of `struct so_list' says which fields
612 we provide values for. */
614 static struct so_list
*
615 dsbt_current_sos (void)
617 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
619 struct so_list
*sos_head
= NULL
;
620 struct so_list
**sos_next_ptr
= &sos_head
;
621 struct dsbt_info
*info
= get_dsbt_info ();
623 /* Make sure that the main executable has been relocated. This is
624 required in order to find the address of the global offset table,
625 which in turn is used to find the link map info. (See lm_base
628 Note that the relocation of the main executable is also performed
629 by solib_create_inferior_hook, however, in the case of core
630 files, this hook is called too late in order to be of benefit to
631 solib_add. solib_add eventually calls this function,
632 dsbt_current_sos, and also precedes the call to
633 solib_create_inferior_hook. (See post_create_inferior in
635 if (info
->main_executable_lm_info
== 0 && core_bfd
!= NULL
)
636 dsbt_relocate_main_executable ();
638 /* Locate the address of the first link map struct. */
639 lm_addr
= lm_base ();
641 /* We have at least one link map entry. Fetch the lot of them,
642 building the solist chain. */
645 struct ext_link_map lm_buf
;
646 ext_Elf32_Word indexword
;
651 if (solib_dsbt_debug
)
652 fprintf_unfiltered (gdb_stdlog
,
653 "current_sos: reading link_map entry at %s\n",
654 hex_string_custom (lm_addr
, 8));
656 ret
= target_read_memory (lm_addr
, (gdb_byte
*) &lm_buf
, sizeof (lm_buf
));
659 warning (_("dsbt_current_sos: Unable to read link map entry."
660 " Shared object chain may be incomplete."));
664 /* Fetch the load map address. */
665 map_addr
= extract_unsigned_integer (lm_buf
.l_addr
.map
,
666 sizeof lm_buf
.l_addr
.map
,
669 ret
= target_read_memory (map_addr
+ 12, (gdb_byte
*) &indexword
,
673 warning (_("dsbt_current_sos: Unable to read dsbt index."
674 " Shared object chain may be incomplete."));
677 dsbt_index
= extract_unsigned_integer (indexword
, sizeof indexword
,
680 /* If the DSBT index is zero, then we're looking at the entry
681 for the main executable. By convention, we don't include
682 this in the list of shared objects. */
685 struct int_elf32_dsbt_loadmap
*loadmap
;
689 loadmap
= fetch_loadmap (map_addr
);
692 warning (_("dsbt_current_sos: Unable to fetch load map."
693 " Shared object chain may be incomplete."));
697 sop
= XCNEW (struct so_list
);
698 lm_info_dsbt
*li
= new lm_info_dsbt
;
701 /* Fetch the name. */
702 addr
= extract_unsigned_integer (lm_buf
.l_name
,
703 sizeof (lm_buf
.l_name
),
705 gdb::unique_xmalloc_ptr
<char> name_buf
706 = target_read_string (addr
, SO_NAME_MAX_PATH_SIZE
- 1);
708 if (name_buf
== nullptr)
709 warning (_("Can't read pathname for link map entry."));
712 if (solib_dsbt_debug
)
713 fprintf_unfiltered (gdb_stdlog
, "current_sos: name = %s\n",
716 strncpy (sop
->so_name
, name_buf
.get (), SO_NAME_MAX_PATH_SIZE
- 1);
717 sop
->so_name
[SO_NAME_MAX_PATH_SIZE
- 1] = '\0';
718 strcpy (sop
->so_original_name
, sop
->so_name
);
722 sos_next_ptr
= &sop
->next
;
726 info
->main_lm_addr
= lm_addr
;
729 lm_addr
= extract_unsigned_integer (lm_buf
.l_next
,
730 sizeof (lm_buf
.l_next
), byte_order
);
736 /* Return 1 if PC lies in the dynamic symbol resolution code of the
740 dsbt_in_dynsym_resolve_code (CORE_ADDR pc
)
742 struct dsbt_info
*info
= get_dsbt_info ();
744 return ((pc
>= info
->interp_text_sect_low
&& pc
< info
->interp_text_sect_high
)
745 || (pc
>= info
->interp_plt_sect_low
&& pc
< info
->interp_plt_sect_high
)
746 || in_plt_section (pc
));
749 /* Print a warning about being unable to set the dynamic linker
753 enable_break_failure_warning (void)
755 warning (_("Unable to find dynamic linker breakpoint function.\n"
756 "GDB will be unable to debug shared library initializers\n"
757 "and track explicitly loaded dynamic code."));
760 /* Helper function for gdb_bfd_lookup_symbol. */
763 cmp_name (const asymbol
*sym
, const void *data
)
765 return (strcmp (sym
->name
, (const char *) data
) == 0);
768 /* The dynamic linkers has, as part of its debugger interface, support
769 for arranging for the inferior to hit a breakpoint after mapping in
770 the shared libraries. This function enables that breakpoint.
772 On the TIC6X, using the shared library (DSBT), GDB can try to place
773 a breakpoint on '_dl_debug_state' to monitor the shared library
779 asection
*interp_sect
;
780 struct dsbt_info
*info
;
782 if (current_program_space
->exec_bfd () == NULL
)
785 if (!target_has_execution ())
788 info
= get_dsbt_info ();
790 info
->interp_text_sect_low
= 0;
791 info
->interp_text_sect_high
= 0;
792 info
->interp_plt_sect_low
= 0;
793 info
->interp_plt_sect_high
= 0;
795 /* Find the .interp section; if not found, warn the user and drop
796 into the old breakpoint at symbol code. */
797 interp_sect
= bfd_get_section_by_name (current_program_space
->exec_bfd (),
801 unsigned int interp_sect_size
;
804 struct int_elf32_dsbt_loadmap
*ldm
;
807 /* Read the contents of the .interp section into a local buffer;
808 the contents specify the dynamic linker this program uses. */
809 interp_sect_size
= bfd_section_size (interp_sect
);
810 buf
= (char *) alloca (interp_sect_size
);
811 bfd_get_section_contents (current_program_space
->exec_bfd (),
812 interp_sect
, buf
, 0, interp_sect_size
);
814 /* Now we need to figure out where the dynamic linker was
815 loaded so that we can load its symbols and place a breakpoint
816 in the dynamic linker itself. */
818 gdb_bfd_ref_ptr tmp_bfd
;
821 tmp_bfd
= solib_bfd_open (buf
);
823 catch (const gdb_exception
&ex
)
829 enable_break_failure_warning ();
833 dsbt_get_initial_loadmaps ();
834 ldm
= info
->interp_loadmap
;
836 /* Record the relocated start and end address of the dynamic linker
837 text and plt section for dsbt_in_dynsym_resolve_code. */
838 interp_sect
= bfd_get_section_by_name (tmp_bfd
.get (), ".text");
841 info
->interp_text_sect_low
= bfd_section_vma (interp_sect
);
842 info
->interp_text_sect_low
843 += displacement_from_map (ldm
, info
->interp_text_sect_low
);
844 info
->interp_text_sect_high
845 = info
->interp_text_sect_low
+ bfd_section_size (interp_sect
);
847 interp_sect
= bfd_get_section_by_name (tmp_bfd
.get (), ".plt");
850 info
->interp_plt_sect_low
= bfd_section_vma (interp_sect
);
851 info
->interp_plt_sect_low
852 += displacement_from_map (ldm
, info
->interp_plt_sect_low
);
853 info
->interp_plt_sect_high
854 = info
->interp_plt_sect_low
+ bfd_section_size (interp_sect
);
857 addr
= gdb_bfd_lookup_symbol (tmp_bfd
.get (), cmp_name
,
861 if (solib_dsbt_debug
)
862 fprintf_unfiltered (gdb_stdlog
,
863 "enable_break: _dl_debug_state (prior to relocation) = %s\n",
864 hex_string_custom (addr
, 8));
865 addr
+= displacement_from_map (ldm
, addr
);
867 if (solib_dsbt_debug
)
868 fprintf_unfiltered (gdb_stdlog
,
869 "enable_break: _dl_debug_state (after relocation) = %s\n",
870 hex_string_custom (addr
, 8));
872 /* Now (finally!) create the solib breakpoint. */
873 create_solib_event_breakpoint (target_gdbarch (), addr
);
879 if (solib_dsbt_debug
)
880 fprintf_unfiltered (gdb_stdlog
,
881 "enable_break: _dl_debug_state is not found\n");
885 /* We're done with the loadmap. */
891 /* Tell the user we couldn't set a dynamic linker breakpoint. */
892 enable_break_failure_warning ();
894 /* Failure return. */
899 dsbt_relocate_main_executable (void)
901 struct int_elf32_dsbt_loadmap
*ldm
;
903 struct obj_section
*osect
;
904 struct dsbt_info
*info
= get_dsbt_info ();
906 dsbt_get_initial_loadmaps ();
907 ldm
= info
->exec_loadmap
;
909 delete info
->main_executable_lm_info
;
910 info
->main_executable_lm_info
= new lm_info_dsbt
;
911 info
->main_executable_lm_info
->map
= ldm
;
913 objfile
*objf
= current_program_space
->symfile_object_file
;
914 section_offsets
new_offsets (objf
->section_offsets
.size ());
917 ALL_OBJFILE_OSECTIONS (objf
, osect
)
919 CORE_ADDR orig_addr
, addr
, offset
;
923 osect_idx
= osect
- objf
->sections
;
925 /* Current address of section. */
926 addr
= obj_section_addr (osect
);
927 /* Offset from where this section started. */
928 offset
= objf
->section_offsets
[osect_idx
];
929 /* Original address prior to any past relocations. */
930 orig_addr
= addr
- offset
;
932 for (seg
= 0; seg
< ldm
->nsegs
; seg
++)
934 if (ldm
->segs
[seg
].p_vaddr
<= orig_addr
935 && orig_addr
< ldm
->segs
[seg
].p_vaddr
+ ldm
->segs
[seg
].p_memsz
)
937 new_offsets
[osect_idx
]
938 = ldm
->segs
[seg
].addr
- ldm
->segs
[seg
].p_vaddr
;
940 if (new_offsets
[osect_idx
] != offset
)
948 objfile_relocate (objf
, new_offsets
);
950 /* Now that OBJF has been relocated, we can compute the GOT value
951 and stash it away. */
954 /* When gdb starts up the inferior, it nurses it along (through the
955 shell) until it is ready to execute it's first instruction. At this
956 point, this function gets called via solib_create_inferior_hook.
958 For the DSBT shared library, the main executable needs to be relocated.
959 The shared library breakpoints also need to be enabled. */
962 dsbt_solib_create_inferior_hook (int from_tty
)
964 /* Relocate main executable. */
965 dsbt_relocate_main_executable ();
967 /* Enable shared library breakpoints. */
968 if (!enable_break ())
970 warning (_("shared library handler failed to enable breakpoint"));
976 dsbt_clear_solib (void)
978 struct dsbt_info
*info
= get_dsbt_info ();
980 info
->lm_base_cache
= 0;
981 info
->main_lm_addr
= 0;
983 delete info
->main_executable_lm_info
;
984 info
->main_executable_lm_info
= NULL
;
988 dsbt_free_so (struct so_list
*so
)
990 lm_info_dsbt
*li
= (lm_info_dsbt
*) so
->lm_info
;
996 dsbt_relocate_section_addresses (struct so_list
*so
,
997 struct target_section
*sec
)
1000 lm_info_dsbt
*li
= (lm_info_dsbt
*) so
->lm_info
;
1001 int_elf32_dsbt_loadmap
*map
= li
->map
;
1003 for (seg
= 0; seg
< map
->nsegs
; seg
++)
1005 if (map
->segs
[seg
].p_vaddr
<= sec
->addr
1006 && sec
->addr
< map
->segs
[seg
].p_vaddr
+ map
->segs
[seg
].p_memsz
)
1008 CORE_ADDR displ
= map
->segs
[seg
].addr
- map
->segs
[seg
].p_vaddr
;
1011 sec
->endaddr
+= displ
;
1017 show_dsbt_debug (struct ui_file
*file
, int from_tty
,
1018 struct cmd_list_element
*c
, const char *value
)
1020 fprintf_filtered (file
, _("solib-dsbt debugging is %s.\n"), value
);
1023 struct target_so_ops dsbt_so_ops
;
1025 void _initialize_dsbt_solib ();
1027 _initialize_dsbt_solib ()
1029 dsbt_so_ops
.relocate_section_addresses
= dsbt_relocate_section_addresses
;
1030 dsbt_so_ops
.free_so
= dsbt_free_so
;
1031 dsbt_so_ops
.clear_solib
= dsbt_clear_solib
;
1032 dsbt_so_ops
.solib_create_inferior_hook
= dsbt_solib_create_inferior_hook
;
1033 dsbt_so_ops
.current_sos
= dsbt_current_sos
;
1034 dsbt_so_ops
.open_symbol_file_object
= open_symbol_file_object
;
1035 dsbt_so_ops
.in_dynsym_resolve_code
= dsbt_in_dynsym_resolve_code
;
1036 dsbt_so_ops
.bfd_open
= solib_bfd_open
;
1038 /* Debug this file's internals. */
1039 add_setshow_zuinteger_cmd ("solib-dsbt", class_maintenance
,
1040 &solib_dsbt_debug
, _("\
1041 Set internal debugging of shared library code for DSBT ELF."), _("\
1042 Show internal debugging of shared library code for DSBT ELF."), _("\
1043 When non-zero, DSBT solib specific internal debugging is enabled."),
1046 &setdebuglist
, &showdebuglist
);