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 */
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
;
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
;
152 struct int_elf32_dsbt_loadmap
*interp_loadmap
;
154 /* Cached value for lm_base, below. */
155 CORE_ADDR lm_base_cache
;
157 /* Link map address for main module. */
158 CORE_ADDR main_lm_addr
;
160 CORE_ADDR interp_text_sect_low
;
161 CORE_ADDR interp_text_sect_high
;
162 CORE_ADDR interp_plt_sect_low
;
163 CORE_ADDR interp_plt_sect_high
;
166 /* Per-program-space data key. */
167 static const struct program_space_data
*solib_dsbt_pspace_data
;
170 dsbt_pspace_data_cleanup (struct program_space
*pspace
, void *arg
)
175 /* Get the current dsbt data. If none is found yet, add it now. This
176 function always returns a valid object. */
178 static struct dsbt_info
*
181 struct dsbt_info
*info
;
183 info
= (struct dsbt_info
*) program_space_data (current_program_space
,
184 solib_dsbt_pspace_data
);
188 info
= XCNEW (struct dsbt_info
);
189 set_program_space_data (current_program_space
, solib_dsbt_pspace_data
, info
);
191 info
->lm_base_cache
= 0;
192 info
->main_lm_addr
= 0;
199 dsbt_print_loadmap (struct int_elf32_dsbt_loadmap
*map
)
204 printf_filtered ("(null)\n");
205 else if (map
->version
!= 0)
206 printf_filtered (_("Unsupported map version: %d\n"), map
->version
);
209 printf_filtered ("version %d\n", map
->version
);
211 for (i
= 0; i
< map
->nsegs
; i
++)
212 printf_filtered ("%s:%s -> %s:%s\n",
213 print_core_address (target_gdbarch (),
214 map
->segs
[i
].p_vaddr
),
215 print_core_address (target_gdbarch (),
217 + map
->segs
[i
].p_memsz
),
218 print_core_address (target_gdbarch (), map
->segs
[i
].addr
),
219 print_core_address (target_gdbarch (), map
->segs
[i
].addr
220 + map
->segs
[i
].p_memsz
));
224 /* Decode int_elf32_dsbt_loadmap from BUF. */
226 static struct int_elf32_dsbt_loadmap
*
227 decode_loadmap (gdb_byte
*buf
)
229 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
230 struct ext_elf32_dsbt_loadmap
*ext_ldmbuf
;
231 struct int_elf32_dsbt_loadmap
*int_ldmbuf
;
233 int version
, seg
, nsegs
;
236 ext_ldmbuf
= (struct ext_elf32_dsbt_loadmap
*) buf
;
238 /* Extract the version. */
239 version
= extract_unsigned_integer (ext_ldmbuf
->version
,
240 sizeof ext_ldmbuf
->version
,
244 /* We only handle version 0. */
248 /* Extract the number of segments. */
249 nsegs
= extract_unsigned_integer (ext_ldmbuf
->nsegs
,
250 sizeof ext_ldmbuf
->nsegs
,
256 /* Allocate space into which to put information extract from the
257 external loadsegs. I.e, allocate the internal loadsegs. */
258 int_ldmbuf_size
= (sizeof (struct int_elf32_dsbt_loadmap
)
259 + (nsegs
- 1) * sizeof (struct int_elf32_dsbt_loadseg
));
260 int_ldmbuf
= (struct int_elf32_dsbt_loadmap
*) xmalloc (int_ldmbuf_size
);
262 /* Place extracted information in internal structs. */
263 int_ldmbuf
->version
= version
;
264 int_ldmbuf
->nsegs
= nsegs
;
265 for (seg
= 0; seg
< nsegs
; seg
++)
267 int_ldmbuf
->segs
[seg
].addr
268 = extract_unsigned_integer (ext_ldmbuf
->segs
[seg
].addr
,
269 sizeof (ext_ldmbuf
->segs
[seg
].addr
),
271 int_ldmbuf
->segs
[seg
].p_vaddr
272 = extract_unsigned_integer (ext_ldmbuf
->segs
[seg
].p_vaddr
,
273 sizeof (ext_ldmbuf
->segs
[seg
].p_vaddr
),
275 int_ldmbuf
->segs
[seg
].p_memsz
276 = extract_unsigned_integer (ext_ldmbuf
->segs
[seg
].p_memsz
,
277 sizeof (ext_ldmbuf
->segs
[seg
].p_memsz
),
286 static struct dsbt_info
*get_dsbt_info (void);
288 /* Interrogate the Linux kernel to find out where the program was loaded.
289 There are two load maps; one for the executable and one for the
290 interpreter (only in the case of a dynamically linked executable). */
293 dsbt_get_initial_loadmaps (void)
296 struct dsbt_info
*info
= get_dsbt_info ();
298 if (0 >= target_read_alloc (¤t_target
, TARGET_OBJECT_FDPIC
,
301 info
->exec_loadmap
= NULL
;
302 error (_("Error reading DSBT exec loadmap"));
304 info
->exec_loadmap
= decode_loadmap (buf
);
305 if (solib_dsbt_debug
)
306 dsbt_print_loadmap (info
->exec_loadmap
);
308 if (0 >= target_read_alloc (¤t_target
, TARGET_OBJECT_FDPIC
,
311 info
->interp_loadmap
= NULL
;
312 error (_("Error reading DSBT interp loadmap"));
314 info
->interp_loadmap
= decode_loadmap (buf
);
315 if (solib_dsbt_debug
)
316 dsbt_print_loadmap (info
->interp_loadmap
);
319 /* Given address LDMADDR, fetch and decode the loadmap at that address.
320 Return NULL if there is a problem reading the target memory or if
321 there doesn't appear to be a loadmap at the given address. The
322 allocated space (representing the loadmap) returned by this
323 function may be freed via a single call to xfree. */
325 static struct int_elf32_dsbt_loadmap
*
326 fetch_loadmap (CORE_ADDR ldmaddr
)
328 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
329 struct ext_elf32_dsbt_loadmap ext_ldmbuf_partial
;
330 struct ext_elf32_dsbt_loadmap
*ext_ldmbuf
;
331 struct int_elf32_dsbt_loadmap
*int_ldmbuf
;
332 int ext_ldmbuf_size
, int_ldmbuf_size
;
333 int version
, seg
, nsegs
;
335 /* Fetch initial portion of the loadmap. */
336 if (target_read_memory (ldmaddr
, (gdb_byte
*) &ext_ldmbuf_partial
,
337 sizeof ext_ldmbuf_partial
))
339 /* Problem reading the target's memory. */
343 /* Extract the version. */
344 version
= extract_unsigned_integer (ext_ldmbuf_partial
.version
,
345 sizeof ext_ldmbuf_partial
.version
,
349 /* We only handle version 0. */
353 /* Extract the number of segments. */
354 nsegs
= extract_unsigned_integer (ext_ldmbuf_partial
.nsegs
,
355 sizeof ext_ldmbuf_partial
.nsegs
,
361 /* Allocate space for the complete (external) loadmap. */
362 ext_ldmbuf_size
= sizeof (struct ext_elf32_dsbt_loadmap
)
363 + (nsegs
- 1) * sizeof (struct ext_elf32_dsbt_loadseg
);
364 ext_ldmbuf
= (struct ext_elf32_dsbt_loadmap
*) xmalloc (ext_ldmbuf_size
);
366 /* Copy over the portion of the loadmap that's already been read. */
367 memcpy (ext_ldmbuf
, &ext_ldmbuf_partial
, sizeof ext_ldmbuf_partial
);
369 /* Read the rest of the loadmap from the target. */
370 if (target_read_memory (ldmaddr
+ sizeof ext_ldmbuf_partial
,
371 (gdb_byte
*) ext_ldmbuf
+ sizeof ext_ldmbuf_partial
,
372 ext_ldmbuf_size
- sizeof ext_ldmbuf_partial
))
374 /* Couldn't read rest of the loadmap. */
379 /* Allocate space into which to put information extract from the
380 external loadsegs. I.e, allocate the internal loadsegs. */
381 int_ldmbuf_size
= sizeof (struct int_elf32_dsbt_loadmap
)
382 + (nsegs
- 1) * sizeof (struct int_elf32_dsbt_loadseg
);
383 int_ldmbuf
= (struct int_elf32_dsbt_loadmap
*) xmalloc (int_ldmbuf_size
);
385 /* Place extracted information in internal structs. */
386 int_ldmbuf
->version
= version
;
387 int_ldmbuf
->nsegs
= nsegs
;
388 for (seg
= 0; seg
< nsegs
; seg
++)
390 int_ldmbuf
->segs
[seg
].addr
391 = extract_unsigned_integer (ext_ldmbuf
->segs
[seg
].addr
,
392 sizeof (ext_ldmbuf
->segs
[seg
].addr
),
394 int_ldmbuf
->segs
[seg
].p_vaddr
395 = extract_unsigned_integer (ext_ldmbuf
->segs
[seg
].p_vaddr
,
396 sizeof (ext_ldmbuf
->segs
[seg
].p_vaddr
),
398 int_ldmbuf
->segs
[seg
].p_memsz
399 = extract_unsigned_integer (ext_ldmbuf
->segs
[seg
].p_memsz
,
400 sizeof (ext_ldmbuf
->segs
[seg
].p_memsz
),
408 static void dsbt_relocate_main_executable (void);
409 static int enable_break (void);
411 /* Scan for DYNTAG in .dynamic section of ABFD. If DYNTAG is found 1 is
412 returned and the corresponding PTR is set. */
415 scan_dyntag (int dyntag
, bfd
*abfd
, CORE_ADDR
*ptr
)
417 int arch_size
, step
, sect_size
;
419 CORE_ADDR dyn_ptr
, dyn_addr
;
420 gdb_byte
*bufend
, *bufstart
, *buf
;
421 Elf32_External_Dyn
*x_dynp_32
;
422 Elf64_External_Dyn
*x_dynp_64
;
423 struct bfd_section
*sect
;
424 struct target_section
*target_section
;
429 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
432 arch_size
= bfd_get_arch_size (abfd
);
436 /* Find the start address of the .dynamic section. */
437 sect
= bfd_get_section_by_name (abfd
, ".dynamic");
441 for (target_section
= current_target_sections
->sections
;
442 target_section
< current_target_sections
->sections_end
;
444 if (sect
== target_section
->the_bfd_section
)
446 if (target_section
< current_target_sections
->sections_end
)
447 dyn_addr
= target_section
->addr
;
450 /* ABFD may come from OBJFILE acting only as a symbol file without being
451 loaded into the target (see add_symbol_file_command). This case is
452 such fallback to the file VMA address without the possibility of
453 having the section relocated to its actual in-memory address. */
455 dyn_addr
= bfd_section_vma (abfd
, sect
);
458 /* Read in .dynamic from the BFD. We will get the actual value
459 from memory later. */
460 sect_size
= bfd_section_size (abfd
, sect
);
461 buf
= bufstart
= (gdb_byte
*) alloca (sect_size
);
462 if (!bfd_get_section_contents (abfd
, sect
,
466 /* Iterate over BUF and scan for DYNTAG. If found, set PTR and return. */
467 step
= (arch_size
== 32) ? sizeof (Elf32_External_Dyn
)
468 : sizeof (Elf64_External_Dyn
);
469 for (bufend
= buf
+ sect_size
;
475 x_dynp_32
= (Elf32_External_Dyn
*) buf
;
476 dyn_tag
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_dynp_32
->d_tag
);
477 dyn_ptr
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_dynp_32
->d_un
.d_ptr
);
481 x_dynp_64
= (Elf64_External_Dyn
*) buf
;
482 dyn_tag
= bfd_h_get_64 (abfd
, (bfd_byte
*) x_dynp_64
->d_tag
);
483 dyn_ptr
= bfd_h_get_64 (abfd
, (bfd_byte
*) x_dynp_64
->d_un
.d_ptr
);
485 if (dyn_tag
== DT_NULL
)
487 if (dyn_tag
== dyntag
)
489 /* If requested, try to read the runtime value of this .dynamic
493 struct type
*ptr_type
;
497 ptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
498 ptr_addr
= dyn_addr
+ (buf
- bufstart
) + arch_size
/ 8;
499 if (target_read_memory (ptr_addr
, ptr_buf
, arch_size
/ 8) == 0)
500 dyn_ptr
= extract_typed_address (ptr_buf
, ptr_type
);
510 /* If no open symbol file, attempt to locate and open the main symbol
513 If FROM_TTYP dereferences to a non-zero integer, allow messages to
514 be printed. This parameter is a pointer rather than an int because
515 open_symbol_file_object is called via catch_errors and
516 catch_errors requires a pointer argument. */
519 open_symbol_file_object (void *from_ttyp
)
525 /* Given a loadmap and an address, return the displacement needed
526 to relocate the address. */
529 displacement_from_map (struct int_elf32_dsbt_loadmap
*map
,
534 for (seg
= 0; seg
< map
->nsegs
; seg
++)
535 if (map
->segs
[seg
].p_vaddr
<= addr
536 && addr
< map
->segs
[seg
].p_vaddr
+ map
->segs
[seg
].p_memsz
)
537 return map
->segs
[seg
].addr
- map
->segs
[seg
].p_vaddr
;
542 /* Return the address from which the link map chain may be found. On
543 DSBT, a pointer to the start of the link map will be located at the
544 word found at base of GOT + GOT_MODULE_OFFSET.
546 The base of GOT may be found in a number of ways. Assuming that the
547 main executable has already been relocated,
548 1 The easiest way to find this value is to look up the address of
549 _GLOBAL_OFFSET_TABLE_.
550 2 The other way is to look for tag DT_PLTGOT, which contains the virtual
551 address of Global Offset Table. .*/
556 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
557 struct bound_minimal_symbol got_sym
;
559 gdb_byte buf
[TIC6X_PTR_SIZE
];
560 struct dsbt_info
*info
= get_dsbt_info ();
562 /* One of our assumptions is that the main executable has been relocated.
563 Bail out if this has not happened. (Note that post_create_inferior
564 in infcmd.c will call solib_add prior to solib_create_inferior_hook.
565 If we allow this to happen, lm_base_cache will be initialized with
567 if (info
->main_executable_lm_info
== 0)
570 /* If we already have a cached value, return it. */
571 if (info
->lm_base_cache
)
572 return info
->lm_base_cache
;
574 got_sym
= lookup_minimal_symbol ("_GLOBAL_OFFSET_TABLE_", NULL
,
577 if (got_sym
.minsym
!= 0)
579 addr
= BMSYMBOL_VALUE_ADDRESS (got_sym
);
580 if (solib_dsbt_debug
)
581 fprintf_unfiltered (gdb_stdlog
,
582 "lm_base: get addr %x by _GLOBAL_OFFSET_TABLE_.\n",
583 (unsigned int) addr
);
585 else if (scan_dyntag (DT_PLTGOT
, exec_bfd
, &addr
))
587 struct int_elf32_dsbt_loadmap
*ldm
;
589 dsbt_get_initial_loadmaps ();
590 ldm
= info
->exec_loadmap
;
591 addr
+= displacement_from_map (ldm
, addr
);
592 if (solib_dsbt_debug
)
593 fprintf_unfiltered (gdb_stdlog
,
594 "lm_base: get addr %x by DT_PLTGOT.\n",
595 (unsigned int) addr
);
599 if (solib_dsbt_debug
)
600 fprintf_unfiltered (gdb_stdlog
,
601 "lm_base: _GLOBAL_OFFSET_TABLE_ not found.\n");
604 addr
+= GOT_MODULE_OFFSET
;
606 if (solib_dsbt_debug
)
607 fprintf_unfiltered (gdb_stdlog
,
608 "lm_base: _GLOBAL_OFFSET_TABLE_ + %d = %s\n",
609 GOT_MODULE_OFFSET
, hex_string_custom (addr
, 8));
611 if (target_read_memory (addr
, buf
, sizeof buf
) != 0)
613 info
->lm_base_cache
= extract_unsigned_integer (buf
, sizeof buf
, byte_order
);
615 if (solib_dsbt_debug
)
616 fprintf_unfiltered (gdb_stdlog
,
617 "lm_base: lm_base_cache = %s\n",
618 hex_string_custom (info
->lm_base_cache
, 8));
620 return info
->lm_base_cache
;
624 /* Build a list of `struct so_list' objects describing the shared
625 objects currently loaded in the inferior. This list does not
626 include an entry for the main executable file.
628 Note that we only gather information directly available from the
629 inferior --- we don't examine any of the shared library files
630 themselves. The declaration of `struct so_list' says which fields
631 we provide values for. */
633 static struct so_list
*
634 dsbt_current_sos (void)
636 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
638 struct so_list
*sos_head
= NULL
;
639 struct so_list
**sos_next_ptr
= &sos_head
;
640 struct dsbt_info
*info
= get_dsbt_info ();
642 /* Make sure that the main executable has been relocated. This is
643 required in order to find the address of the global offset table,
644 which in turn is used to find the link map info. (See lm_base
647 Note that the relocation of the main executable is also performed
648 by solib_create_inferior_hook, however, in the case of core
649 files, this hook is called too late in order to be of benefit to
650 solib_add. solib_add eventually calls this function,
651 dsbt_current_sos, and also precedes the call to
652 solib_create_inferior_hook. (See post_create_inferior in
654 if (info
->main_executable_lm_info
== 0 && core_bfd
!= NULL
)
655 dsbt_relocate_main_executable ();
657 /* Locate the address of the first link map struct. */
658 lm_addr
= lm_base ();
660 /* We have at least one link map entry. Fetch the the lot of them,
661 building the solist chain. */
664 struct ext_link_map lm_buf
;
665 ext_Elf32_Word indexword
;
670 if (solib_dsbt_debug
)
671 fprintf_unfiltered (gdb_stdlog
,
672 "current_sos: reading link_map entry at %s\n",
673 hex_string_custom (lm_addr
, 8));
675 ret
= target_read_memory (lm_addr
, (gdb_byte
*) &lm_buf
, sizeof (lm_buf
));
678 warning (_("dsbt_current_sos: Unable to read link map entry."
679 " Shared object chain may be incomplete."));
683 /* Fetch the load map address. */
684 map_addr
= extract_unsigned_integer (lm_buf
.l_addr
.map
,
685 sizeof lm_buf
.l_addr
.map
,
688 ret
= target_read_memory (map_addr
+ 12, (gdb_byte
*) &indexword
,
692 warning (_("dsbt_current_sos: Unable to read dsbt index."
693 " Shared object chain may be incomplete."));
696 dsbt_index
= extract_unsigned_integer (indexword
, sizeof indexword
,
699 /* If the DSBT index is zero, then we're looking at the entry
700 for the main executable. By convention, we don't include
701 this in the list of shared objects. */
706 struct int_elf32_dsbt_loadmap
*loadmap
;
710 loadmap
= fetch_loadmap (map_addr
);
713 warning (_("dsbt_current_sos: Unable to fetch load map."
714 " Shared object chain may be incomplete."));
718 sop
= XCNEW (struct so_list
);
719 lm_info_dsbt
*li
= new lm_info_dsbt
;
722 /* Fetch the name. */
723 addr
= extract_unsigned_integer (lm_buf
.l_name
,
724 sizeof (lm_buf
.l_name
),
726 target_read_string (addr
, &name_buf
, SO_NAME_MAX_PATH_SIZE
- 1,
730 warning (_("Can't read pathname for link map entry: %s."),
731 safe_strerror (errcode
));
734 if (solib_dsbt_debug
)
735 fprintf_unfiltered (gdb_stdlog
, "current_sos: name = %s\n",
738 strncpy (sop
->so_name
, name_buf
, SO_NAME_MAX_PATH_SIZE
- 1);
739 sop
->so_name
[SO_NAME_MAX_PATH_SIZE
- 1] = '\0';
741 strcpy (sop
->so_original_name
, sop
->so_name
);
745 sos_next_ptr
= &sop
->next
;
749 info
->main_lm_addr
= lm_addr
;
752 lm_addr
= extract_unsigned_integer (lm_buf
.l_next
,
753 sizeof (lm_buf
.l_next
), byte_order
);
759 /* Return 1 if PC lies in the dynamic symbol resolution code of the
763 dsbt_in_dynsym_resolve_code (CORE_ADDR pc
)
765 struct dsbt_info
*info
= get_dsbt_info ();
767 return ((pc
>= info
->interp_text_sect_low
&& pc
< info
->interp_text_sect_high
)
768 || (pc
>= info
->interp_plt_sect_low
&& pc
< info
->interp_plt_sect_high
)
769 || in_plt_section (pc
));
772 /* Print a warning about being unable to set the dynamic linker
776 enable_break_failure_warning (void)
778 warning (_("Unable to find dynamic linker breakpoint function.\n"
779 "GDB will be unable to debug shared library initializers\n"
780 "and track explicitly loaded dynamic code."));
783 /* Helper function for gdb_bfd_lookup_symbol. */
786 cmp_name (const asymbol
*sym
, const void *data
)
788 return (strcmp (sym
->name
, (const char *) data
) == 0);
791 /* The dynamic linkers has, as part of its debugger interface, support
792 for arranging for the inferior to hit a breakpoint after mapping in
793 the shared libraries. This function enables that breakpoint.
795 On the TIC6X, using the shared library (DSBT), GDB can try to place
796 a breakpoint on '_dl_debug_state' to monitor the shared library
802 asection
*interp_sect
;
803 struct dsbt_info
*info
;
805 if (exec_bfd
== NULL
)
808 if (!target_has_execution
)
811 info
= get_dsbt_info ();
813 info
->interp_text_sect_low
= 0;
814 info
->interp_text_sect_high
= 0;
815 info
->interp_plt_sect_low
= 0;
816 info
->interp_plt_sect_high
= 0;
818 /* Find the .interp section; if not found, warn the user and drop
819 into the old breakpoint at symbol code. */
820 interp_sect
= bfd_get_section_by_name (exec_bfd
, ".interp");
823 unsigned int interp_sect_size
;
826 struct int_elf32_dsbt_loadmap
*ldm
;
829 /* Read the contents of the .interp section into a local buffer;
830 the contents specify the dynamic linker this program uses. */
831 interp_sect_size
= bfd_section_size (exec_bfd
, interp_sect
);
832 buf
= (char *) alloca (interp_sect_size
);
833 bfd_get_section_contents (exec_bfd
, interp_sect
,
834 buf
, 0, interp_sect_size
);
836 /* Now we need to figure out where the dynamic linker was
837 loaded so that we can load its symbols and place a breakpoint
838 in the dynamic linker itself. */
840 gdb_bfd_ref_ptr tmp_bfd
;
843 tmp_bfd
= solib_bfd_open (buf
);
845 CATCH (ex
, RETURN_MASK_ALL
)
852 enable_break_failure_warning ();
856 dsbt_get_initial_loadmaps ();
857 ldm
= info
->interp_loadmap
;
859 /* Record the relocated start and end address of the dynamic linker
860 text and plt section for dsbt_in_dynsym_resolve_code. */
861 interp_sect
= bfd_get_section_by_name (tmp_bfd
.get (), ".text");
864 info
->interp_text_sect_low
865 = bfd_section_vma (tmp_bfd
.get (), interp_sect
);
866 info
->interp_text_sect_low
867 += displacement_from_map (ldm
, info
->interp_text_sect_low
);
868 info
->interp_text_sect_high
869 = info
->interp_text_sect_low
870 + bfd_section_size (tmp_bfd
.get (), interp_sect
);
872 interp_sect
= bfd_get_section_by_name (tmp_bfd
.get (), ".plt");
875 info
->interp_plt_sect_low
=
876 bfd_section_vma (tmp_bfd
.get (), interp_sect
);
877 info
->interp_plt_sect_low
878 += displacement_from_map (ldm
, info
->interp_plt_sect_low
);
879 info
->interp_plt_sect_high
=
880 info
->interp_plt_sect_low
+ bfd_section_size (tmp_bfd
.get (),
884 addr
= gdb_bfd_lookup_symbol (tmp_bfd
.get (), cmp_name
,
888 if (solib_dsbt_debug
)
889 fprintf_unfiltered (gdb_stdlog
,
890 "enable_break: _dl_debug_state (prior to relocation) = %s\n",
891 hex_string_custom (addr
, 8));
892 addr
+= displacement_from_map (ldm
, addr
);
894 if (solib_dsbt_debug
)
895 fprintf_unfiltered (gdb_stdlog
,
896 "enable_break: _dl_debug_state (after relocation) = %s\n",
897 hex_string_custom (addr
, 8));
899 /* Now (finally!) create the solib breakpoint. */
900 create_solib_event_breakpoint (target_gdbarch (), addr
);
906 if (solib_dsbt_debug
)
907 fprintf_unfiltered (gdb_stdlog
,
908 "enable_break: _dl_debug_state is not found\n");
912 /* We're done with the loadmap. */
918 /* Tell the user we couldn't set a dynamic linker breakpoint. */
919 enable_break_failure_warning ();
921 /* Failure return. */
926 dsbt_relocate_main_executable (void)
928 struct int_elf32_dsbt_loadmap
*ldm
;
929 struct cleanup
*old_chain
;
930 struct section_offsets
*new_offsets
;
932 struct obj_section
*osect
;
933 struct dsbt_info
*info
= get_dsbt_info ();
935 dsbt_get_initial_loadmaps ();
936 ldm
= info
->exec_loadmap
;
938 delete info
->main_executable_lm_info
;
939 info
->main_executable_lm_info
= new lm_info_dsbt
;
940 info
->main_executable_lm_info
->map
= ldm
;
942 new_offsets
= XCNEWVEC (struct section_offsets
,
943 symfile_objfile
->num_sections
);
944 old_chain
= make_cleanup (xfree
, new_offsets
);
947 ALL_OBJFILE_OSECTIONS (symfile_objfile
, osect
)
949 CORE_ADDR orig_addr
, addr
, offset
;
953 osect_idx
= osect
- symfile_objfile
->sections
;
955 /* Current address of section. */
956 addr
= obj_section_addr (osect
);
957 /* Offset from where this section started. */
958 offset
= ANOFFSET (symfile_objfile
->section_offsets
, osect_idx
);
959 /* Original address prior to any past relocations. */
960 orig_addr
= addr
- offset
;
962 for (seg
= 0; seg
< ldm
->nsegs
; seg
++)
964 if (ldm
->segs
[seg
].p_vaddr
<= orig_addr
965 && orig_addr
< ldm
->segs
[seg
].p_vaddr
+ ldm
->segs
[seg
].p_memsz
)
967 new_offsets
->offsets
[osect_idx
]
968 = ldm
->segs
[seg
].addr
- ldm
->segs
[seg
].p_vaddr
;
970 if (new_offsets
->offsets
[osect_idx
] != offset
)
978 objfile_relocate (symfile_objfile
, new_offsets
);
980 do_cleanups (old_chain
);
982 /* Now that symfile_objfile has been relocated, we can compute the
983 GOT value and stash it away. */
986 /* When gdb starts up the inferior, it nurses it along (through the
987 shell) until it is ready to execute it's first instruction. At this
988 point, this function gets called via solib_create_inferior_hook.
990 For the DSBT shared library, the main executable needs to be relocated.
991 The shared library breakpoints also need to be enabled. */
994 dsbt_solib_create_inferior_hook (int from_tty
)
996 /* Relocate main executable. */
997 dsbt_relocate_main_executable ();
999 /* Enable shared library breakpoints. */
1000 if (!enable_break ())
1002 warning (_("shared library handler failed to enable breakpoint"));
1008 dsbt_clear_solib (void)
1010 struct dsbt_info
*info
= get_dsbt_info ();
1012 info
->lm_base_cache
= 0;
1013 info
->main_lm_addr
= 0;
1015 delete info
->main_executable_lm_info
;
1016 info
->main_executable_lm_info
= NULL
;
1020 dsbt_free_so (struct so_list
*so
)
1022 lm_info_dsbt
*li
= (lm_info_dsbt
*) so
->lm_info
;
1028 dsbt_relocate_section_addresses (struct so_list
*so
,
1029 struct target_section
*sec
)
1032 lm_info_dsbt
*li
= (lm_info_dsbt
*) so
->lm_info
;
1033 int_elf32_dsbt_loadmap
*map
= li
->map
;
1035 for (seg
= 0; seg
< map
->nsegs
; seg
++)
1037 if (map
->segs
[seg
].p_vaddr
<= sec
->addr
1038 && sec
->addr
< map
->segs
[seg
].p_vaddr
+ map
->segs
[seg
].p_memsz
)
1040 CORE_ADDR displ
= map
->segs
[seg
].addr
- map
->segs
[seg
].p_vaddr
;
1043 sec
->endaddr
+= displ
;
1049 show_dsbt_debug (struct ui_file
*file
, int from_tty
,
1050 struct cmd_list_element
*c
, const char *value
)
1052 fprintf_filtered (file
, _("solib-dsbt debugging is %s.\n"), value
);
1055 struct target_so_ops dsbt_so_ops
;
1057 /* Provide a prototype to silence -Wmissing-prototypes. */
1058 extern initialize_file_ftype _initialize_dsbt_solib
;
1061 _initialize_dsbt_solib (void)
1063 solib_dsbt_pspace_data
1064 = register_program_space_data_with_cleanup (NULL
, dsbt_pspace_data_cleanup
);
1066 dsbt_so_ops
.relocate_section_addresses
= dsbt_relocate_section_addresses
;
1067 dsbt_so_ops
.free_so
= dsbt_free_so
;
1068 dsbt_so_ops
.clear_solib
= dsbt_clear_solib
;
1069 dsbt_so_ops
.solib_create_inferior_hook
= dsbt_solib_create_inferior_hook
;
1070 dsbt_so_ops
.current_sos
= dsbt_current_sos
;
1071 dsbt_so_ops
.open_symbol_file_object
= open_symbol_file_object
;
1072 dsbt_so_ops
.in_dynsym_resolve_code
= dsbt_in_dynsym_resolve_code
;
1073 dsbt_so_ops
.bfd_open
= solib_bfd_open
;
1075 /* Debug this file's internals. */
1076 add_setshow_zuinteger_cmd ("solib-dsbt", class_maintenance
,
1077 &solib_dsbt_debug
, _("\
1078 Set internal debugging of shared library code for DSBT ELF."), _("\
1079 Show internal debugging of shared library code for DSBT ELF."), _("\
1080 When non-zero, DSBT solib specific internal debugging is enabled."),
1083 &setdebuglist
, &showdebuglist
);