GDB (xrefs)

/tmp/gdb-8.1/gdb/solib-dsbt.c
Go to the documentation of this file.
1 /* Handle TIC6X (DSBT) shared libraries for GDB, the GNU Debugger.
2 Copyright (C) 2010-2018 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 "inferior.h"
22 #include "gdbcore.h"
23 #include "solib.h"
24 #include "solist.h"
25 #include "objfiles.h"
26 #include "symtab.h"
27 #include "language.h"
28 #include "command.h"
29 #include "gdbcmd.h"
30 #include "elf-bfd.h"
31 #include "gdb_bfd.h"
32
33 #define GOT_MODULE_OFFSET 4
34
35 /* Flag which indicates whether internal debug messages should be printed. */
36 static unsigned int solib_dsbt_debug = 0;
37
38 /* TIC6X pointers are four bytes wide. */
39 enum { TIC6X_PTR_SIZE = 4 };
40
41 /* Representation of loadmap and related structs for the TIC6X DSBT. */
42
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];
49
50 struct ext_elf32_dsbt_loadseg
51 {
52 /* Core address to which the segment is mapped. */
53 ext_Elf32_Addr addr;
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;
58 };
59
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
64 module. */
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. */
69 ext_Elf32_Word nsegs;
70 /* The actual memory map. */
71 struct ext_elf32_dsbt_loadseg segs[1 /* nsegs, actually */];
72 };
73
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
78 {
79 /* Core address to which the segment is mapped. */
80 CORE_ADDR addr;
81 /* VMA recorded in the program header. */
82 CORE_ADDR p_vaddr;
83 /* Size of this segment in memory. */
84 long p_memsz;
85 };
86
87 struct int_elf32_dsbt_loadmap
88 {
89 /* Protocol version number, must be zero. */
90 int version;
91 CORE_ADDR dsbt_table_ptr;
92 /* A pointer to the DSBT table; the DSBT size and the index of this
93 module. */
94 int dsbt_size, dsbt_index;
95 /* Number of segments in this map. */
96 int nsegs;
97 /* The actual memory map. */
98 struct int_elf32_dsbt_loadseg segs[1 /* nsegs, actually */];
99 };
100
101 /* External link_map and elf32_dsbt_loadaddr struct definitions. */
102
103 typedef gdb_byte ext_ptr[4];
104
105 struct ext_elf32_dsbt_loadaddr
106 {
107 ext_ptr map; /* struct elf32_dsbt_loadmap *map; */
108 };
109
110 struct ext_link_map
111 {
112 struct ext_elf32_dsbt_loadaddr l_addr;
113
114 /* Absolute file name object was found in. */
115 ext_ptr l_name; /* char *l_name; */
116
117 /* Dynamic section of the shared object. */
118 ext_ptr l_ld; /* ElfW(Dyn) *l_ld; */
119
120 /* Chain of loaded objects. */
121 ext_ptr l_next, l_prev; /* struct link_map *l_next, *l_prev; */
122 };
123
124 /* Link map info to include in an allocated so_list entry */
125
126 struct lm_info_dsbt : public lm_info_base
127 {
128 ~lm_info_dsbt ()
129 {
130 xfree (this->map);
131 }
132
133 /* The loadmap, digested into an easier to use form. */
134 int_elf32_dsbt_loadmap *map = NULL;
135 };
136
137 /* Per pspace dsbt specific data. */
138
139 struct dsbt_info
140 {
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;
146
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
150 each module. */
151 struct int_elf32_dsbt_loadmap *exec_loadmap;
152 struct int_elf32_dsbt_loadmap *interp_loadmap;
153
154 /* Cached value for lm_base, below. */
155 CORE_ADDR lm_base_cache;
156
157 /* Link map address for main module. */
158 CORE_ADDR main_lm_addr;
159
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;
164 };
165
166 /* Per-program-space data key. */
167 static const struct program_space_data *solib_dsbt_pspace_data;
168
169 static void
170 dsbt_pspace_data_cleanup (struct program_space *pspace, void *arg)
171 {
172 xfree (arg);
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 = (struct dsbt_info *) program_space_data (current_program_space,
184 solib_dsbt_pspace_data);
185 if (info != NULL)
186 return info;
187
188 info = XCNEW (struct dsbt_info);
189 set_program_space_data (current_program_space, solib_dsbt_pspace_data, info);
190
191 info->lm_base_cache = 0;
192 info->main_lm_addr = 0;
193
194 return info;
195 }
196
197
198 static void
199 dsbt_print_loadmap (struct int_elf32_dsbt_loadmap *map)
200 {
201 int i;
202
203 if (map == NULL)
204 printf_filtered ("(null)\n");
205 else if (map->version != 0)
206 printf_filtered (_("Unsupported map version: %d\n"), map->version);
207 else
208 {
209 printf_filtered ("version %d\n", map->version);
210
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 (),
216 map->segs[i].p_vaddr
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));
221 }
222 }
223
224 /* Decode int_elf32_dsbt_loadmap from BUF. */
225
226 static struct int_elf32_dsbt_loadmap *
227 decode_loadmap (gdb_byte *buf)
228 {
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;
232
233 int version, seg, nsegs;
234 int int_ldmbuf_size;
235
236 ext_ldmbuf = (struct ext_elf32_dsbt_loadmap *) buf;
237
238 /* Extract the version. */
239 version = extract_unsigned_integer (ext_ldmbuf->version,
240 sizeof ext_ldmbuf->version,
241 byte_order);
242 if (version != 0)
243 {
244 /* We only handle version 0. */
245 return NULL;
246 }
247
248 /* Extract the number of segments. */
249 nsegs = extract_unsigned_integer (ext_ldmbuf->nsegs,
250 sizeof ext_ldmbuf->nsegs,
251 byte_order);
252
253 if (nsegs <= 0)
254 return NULL;
255
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);
261
262 /* Place extracted information in internal structs. */
263 int_ldmbuf->version = version;
264 int_ldmbuf->nsegs = nsegs;
265 for (seg = 0; seg < nsegs; seg++)
266 {
267 int_ldmbuf->segs[seg].addr
268 = extract_unsigned_integer (ext_ldmbuf->segs[seg].addr,
269 sizeof (ext_ldmbuf->segs[seg].addr),
270 byte_order);
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),
274 byte_order);
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),
278 byte_order);
279 }
280
281 xfree (ext_ldmbuf);
282 return int_ldmbuf;
283 }
284
285
286 static struct dsbt_info *get_dsbt_info (void);
287
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). */
291
292 static void
293 dsbt_get_initial_loadmaps (void)
294 {
295 gdb_byte *buf;
296 struct dsbt_info *info = get_dsbt_info ();
297
298 if (0 >= target_read_alloc (&current_target, TARGET_OBJECT_FDPIC,
299 "exec", &buf))
300 {
301 info->exec_loadmap = NULL;
302 error (_("Error reading DSBT exec loadmap"));
303 }
304 info->exec_loadmap = decode_loadmap (buf);
305 if (solib_dsbt_debug)
306 dsbt_print_loadmap (info->exec_loadmap);
307
308 if (0 >= target_read_alloc (&current_target, TARGET_OBJECT_FDPIC,
309 "interp", &buf))
310 {
311 info->interp_loadmap = NULL;
312 error (_("Error reading DSBT interp loadmap"));
313 }
314 info->interp_loadmap = decode_loadmap (buf);
315 if (solib_dsbt_debug)
316 dsbt_print_loadmap (info->interp_loadmap);
317 }
318
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. */
324
325 static struct int_elf32_dsbt_loadmap *
326 fetch_loadmap (CORE_ADDR ldmaddr)
327 {
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;
334
335 /* Fetch initial portion of the loadmap. */
336 if (target_read_memory (ldmaddr, (gdb_byte *) &ext_ldmbuf_partial,
337 sizeof ext_ldmbuf_partial))
338 {
339 /* Problem reading the target's memory. */
340 return NULL;
341 }
342
343 /* Extract the version. */
344 version = extract_unsigned_integer (ext_ldmbuf_partial.version,
345 sizeof ext_ldmbuf_partial.version,
346 byte_order);
347 if (version != 0)
348 {
349 /* We only handle version 0. */
350 return NULL;
351 }
352
353 /* Extract the number of segments. */
354 nsegs = extract_unsigned_integer (ext_ldmbuf_partial.nsegs,
355 sizeof ext_ldmbuf_partial.nsegs,
356 byte_order);
357
358 if (nsegs <= 0)
359 return NULL;
360
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);
365
366 /* Copy over the portion of the loadmap that's already been read. */
367 memcpy (ext_ldmbuf, &ext_ldmbuf_partial, sizeof ext_ldmbuf_partial);
368
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))
373 {
374 /* Couldn't read rest of the loadmap. */
375 xfree (ext_ldmbuf);
376 return NULL;
377 }
378
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);
384
385 /* Place extracted information in internal structs. */
386 int_ldmbuf->version = version;
387 int_ldmbuf->nsegs = nsegs;
388 for (seg = 0; seg < nsegs; seg++)
389 {
390 int_ldmbuf->segs[seg].addr
391 = extract_unsigned_integer (ext_ldmbuf->segs[seg].addr,
392 sizeof (ext_ldmbuf->segs[seg].addr),
393 byte_order);
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),
397 byte_order);
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),
401 byte_order);
402 }
403
404 xfree (ext_ldmbuf);
405 return int_ldmbuf;
406 }
407
408 static void dsbt_relocate_main_executable (void);
409 static int enable_break (void);
410
411 /* Scan for DYNTAG in .dynamic section of ABFD. If DYNTAG is found 1 is
412 returned and the corresponding PTR is set. */
413
414 static int
415 scan_dyntag (int dyntag, bfd *abfd, CORE_ADDR *ptr)
416 {
417 int arch_size, step, sect_size;
418 long dyn_tag;
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;
425
426 if (abfd == NULL)
427 return 0;
428
429 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
430 return 0;
431
432 arch_size = bfd_get_arch_size (abfd);
433 if (arch_size == -1)
434 return 0;
435
436 /* Find the start address of the .dynamic section. */
437 sect = bfd_get_section_by_name (abfd, ".dynamic");
438 if (sect == NULL)
439 return 0;
440
441 for (target_section = current_target_sections->sections;
442 target_section < current_target_sections->sections_end;
443 target_section++)
444 if (sect == target_section->the_bfd_section)
445 break;
446 if (target_section < current_target_sections->sections_end)
447 dyn_addr = target_section->addr;
448 else
449 {
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. */
454
455 dyn_addr = bfd_section_vma (abfd, sect);
456 }
457
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,
463 buf, 0, sect_size))
464 return 0;
465
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;
470 buf < bufend;
471 buf += step)
472 {
473 if (arch_size == 32)
474 {
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);
478 }
479 else
480 {
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);
484 }
485 if (dyn_tag == DT_NULL)
486 return 0;
487 if (dyn_tag == dyntag)
488 {
489 /* If requested, try to read the runtime value of this .dynamic
490 entry. */
491 if (ptr)
492 {
493 struct type *ptr_type;
494 gdb_byte ptr_buf[8];
495 CORE_ADDR ptr_addr;
496
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);
501 *ptr = dyn_ptr;
502 }
503 return 1;
504 }
505 }
506
507 return 0;
508 }
509
510 /* See solist.h. */
511
512 static int
513 open_symbol_file_object (int from_tty)
514 {
515 /* Unimplemented. */
516 return 0;
517 }
518
519 /* Given a loadmap and an address, return the displacement needed
520 to relocate the address. */
521
522 static CORE_ADDR
523 displacement_from_map (struct int_elf32_dsbt_loadmap *map,
524 CORE_ADDR addr)
525 {
526 int seg;
527
528 for (seg = 0; seg < map->nsegs; seg++)
529 if (map->segs[seg].p_vaddr <= addr
530 && addr < map->segs[seg].p_vaddr + map->segs[seg].p_memsz)
531 return map->segs[seg].addr - map->segs[seg].p_vaddr;
532
533 return 0;
534 }
535
536 /* Return the address from which the link map chain may be found. On
537 DSBT, a pointer to the start of the link map will be located at the
538 word found at base of GOT + GOT_MODULE_OFFSET.
539
540 The base of GOT may be found in a number of ways. Assuming that the
541 main executable has already been relocated,
542 1 The easiest way to find this value is to look up the address of
543 _GLOBAL_OFFSET_TABLE_.
544 2 The other way is to look for tag DT_PLTGOT, which contains the virtual
545 address of Global Offset Table. .*/
546
547 static CORE_ADDR
548 lm_base (void)
549 {
550 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
551 struct bound_minimal_symbol got_sym;
552 CORE_ADDR addr;
553 gdb_byte buf[TIC6X_PTR_SIZE];
554 struct dsbt_info *info = get_dsbt_info ();
555
556 /* One of our assumptions is that the main executable has been relocated.
557 Bail out if this has not happened. (Note that post_create_inferior
558 in infcmd.c will call solib_add prior to solib_create_inferior_hook.
559 If we allow this to happen, lm_base_cache will be initialized with
560 a bogus value. */
561 if (info->main_executable_lm_info == 0)
562 return 0;
563
564 /* If we already have a cached value, return it. */
565 if (info->lm_base_cache)
566 return info->lm_base_cache;
567
568 got_sym = lookup_minimal_symbol ("_GLOBAL_OFFSET_TABLE_", NULL,
569 symfile_objfile);
570
571 if (got_sym.minsym != 0)
572 {
573 addr = BMSYMBOL_VALUE_ADDRESS (got_sym);
574 if (solib_dsbt_debug)
575 fprintf_unfiltered (gdb_stdlog,
576 "lm_base: get addr %x by _GLOBAL_OFFSET_TABLE_.\n",
577 (unsigned int) addr);
578 }
579 else if (scan_dyntag (DT_PLTGOT, exec_bfd, &addr))
580 {
581 struct int_elf32_dsbt_loadmap *ldm;
582
583 dsbt_get_initial_loadmaps ();
584 ldm = info->exec_loadmap;
585 addr += displacement_from_map (ldm, addr);
586 if (solib_dsbt_debug)
587 fprintf_unfiltered (gdb_stdlog,
588 "lm_base: get addr %x by DT_PLTGOT.\n",
589 (unsigned int) addr);
590 }
591 else
592 {
593 if (solib_dsbt_debug)
594 fprintf_unfiltered (gdb_stdlog,
595 "lm_base: _GLOBAL_OFFSET_TABLE_ not found.\n");
596 return 0;
597 }
598 addr += GOT_MODULE_OFFSET;
599
600 if (solib_dsbt_debug)
601 fprintf_unfiltered (gdb_stdlog,
602 "lm_base: _GLOBAL_OFFSET_TABLE_ + %d = %s\n",
603 GOT_MODULE_OFFSET, hex_string_custom (addr, 8));
604
605 if (target_read_memory (addr, buf, sizeof buf) != 0)
606 return 0;
607 info->lm_base_cache = extract_unsigned_integer (buf, sizeof buf, byte_order);
608
609 if (solib_dsbt_debug)
610 fprintf_unfiltered (gdb_stdlog,
611 "lm_base: lm_base_cache = %s\n",
612 hex_string_custom (info->lm_base_cache, 8));
613
614 return info->lm_base_cache;
615 }
616
617
618 /* Build a list of `struct so_list' objects describing the shared
619 objects currently loaded in the inferior. This list does not
620 include an entry for the main executable file.
621
622 Note that we only gather information directly available from the
623 inferior --- we don't examine any of the shared library files
624 themselves. The declaration of `struct so_list' says which fields
625 we provide values for. */
626
627 static struct so_list *
628 dsbt_current_sos (void)
629 {
630 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
631 CORE_ADDR lm_addr;
632 struct so_list *sos_head = NULL;
633 struct so_list **sos_next_ptr = &sos_head;
634 struct dsbt_info *info = get_dsbt_info ();
635
636 /* Make sure that the main executable has been relocated. This is
637 required in order to find the address of the global offset table,
638 which in turn is used to find the link map info. (See lm_base
639 for details.)
640
641 Note that the relocation of the main executable is also performed
642 by solib_create_inferior_hook, however, in the case of core
643 files, this hook is called too late in order to be of benefit to
644 solib_add. solib_add eventually calls this function,
645 dsbt_current_sos, and also precedes the call to
646 solib_create_inferior_hook. (See post_create_inferior in
647 infcmd.c.) */
648 if (info->main_executable_lm_info == 0 && core_bfd != NULL)
649 dsbt_relocate_main_executable ();
650
651 /* Locate the address of the first link map struct. */
652 lm_addr = lm_base ();
653
654 /* We have at least one link map entry. Fetch the the lot of them,
655 building the solist chain. */
656 while (lm_addr)
657 {
658 struct ext_link_map lm_buf;
659 ext_Elf32_Word indexword;
660 CORE_ADDR map_addr;
661 int dsbt_index;
662 int ret;
663
664 if (solib_dsbt_debug)
665 fprintf_unfiltered (gdb_stdlog,
666 "current_sos: reading link_map entry at %s\n",
667 hex_string_custom (lm_addr, 8));
668
669 ret = target_read_memory (lm_addr, (gdb_byte *) &lm_buf, sizeof (lm_buf));
670 if (ret)
671 {
672 warning (_("dsbt_current_sos: Unable to read link map entry."
673 " Shared object chain may be incomplete."));
674 break;
675 }
676
677 /* Fetch the load map address. */
678 map_addr = extract_unsigned_integer (lm_buf.l_addr.map,
679 sizeof lm_buf.l_addr.map,
680 byte_order);
681
682 ret = target_read_memory (map_addr + 12, (gdb_byte *) &indexword,
683 sizeof indexword);
684 if (ret)
685 {
686 warning (_("dsbt_current_sos: Unable to read dsbt index."
687 " Shared object chain may be incomplete."));
688 break;
689 }
690 dsbt_index = extract_unsigned_integer (indexword, sizeof indexword,
691 byte_order);
692
693 /* If the DSBT index is zero, then we're looking at the entry
694 for the main executable. By convention, we don't include
695 this in the list of shared objects. */
696 if (dsbt_index != 0)
697 {
698 int errcode;
699 char *name_buf;
700 struct int_elf32_dsbt_loadmap *loadmap;
701 struct so_list *sop;
702 CORE_ADDR addr;
703
704 loadmap = fetch_loadmap (map_addr);
705 if (loadmap == NULL)
706 {
707 warning (_("dsbt_current_sos: Unable to fetch load map."
708 " Shared object chain may be incomplete."));
709 break;
710 }
711
712 sop = XCNEW (struct so_list);
713 lm_info_dsbt *li = new lm_info_dsbt;
714 sop->lm_info = li;
715 li->map = loadmap;
716 /* Fetch the name. */
717 addr = extract_unsigned_integer (lm_buf.l_name,
718 sizeof (lm_buf.l_name),
719 byte_order);
720 target_read_string (addr, &name_buf, SO_NAME_MAX_PATH_SIZE - 1,
721 &errcode);
722
723 if (errcode != 0)
724 warning (_("Can't read pathname for link map entry: %s."),
725 safe_strerror (errcode));
726 else
727 {
728 if (solib_dsbt_debug)
729 fprintf_unfiltered (gdb_stdlog, "current_sos: name = %s\n",
730 name_buf);
731
732 strncpy (sop->so_name, name_buf, SO_NAME_MAX_PATH_SIZE - 1);
733 sop->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
734 xfree (name_buf);
735 strcpy (sop->so_original_name, sop->so_name);
736 }
737
738 *sos_next_ptr = sop;
739 sos_next_ptr = &sop->next;
740 }
741 else
742 {
743 info->main_lm_addr = lm_addr;
744 }
745
746 lm_addr = extract_unsigned_integer (lm_buf.l_next,
747 sizeof (lm_buf.l_next), byte_order);
748 }
749
750 return sos_head;
751 }
752
753 /* Return 1 if PC lies in the dynamic symbol resolution code of the
754 run time loader. */
755
756 static int
757 dsbt_in_dynsym_resolve_code (CORE_ADDR pc)
758 {
759 struct dsbt_info *info = get_dsbt_info ();
760
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));
764 }
765
766 /* Print a warning about being unable to set the dynamic linker
767 breakpoint. */
768
769 static void
770 enable_break_failure_warning (void)
771 {
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."));
775 }
776
777 /* Helper function for gdb_bfd_lookup_symbol. */
778
779 static int
780 cmp_name (const asymbol *sym, const void *data)
781 {
782 return (strcmp (sym->name, (const char *) data) == 0);
783 }
784
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.
788
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
791 event. */
792
793 static int
794 enable_break (void)
795 {
796 asection *interp_sect;
797 struct dsbt_info *info;
798
799 if (exec_bfd == NULL)
800 return 0;
801
802 if (!target_has_execution)
803 return 0;
804
805 info = get_dsbt_info ();
806
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;
811
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");
815 if (interp_sect)
816 {
817 unsigned int interp_sect_size;
818 char *buf;
819 CORE_ADDR addr;
820 struct int_elf32_dsbt_loadmap *ldm;
821 int ret;
822
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);
829
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. */
833
834 gdb_bfd_ref_ptr tmp_bfd;
835 TRY
836 {
837 tmp_bfd = solib_bfd_open (buf);
838 }
839 CATCH (ex, RETURN_MASK_ALL)
840 {
841 }
842 END_CATCH
843
844 if (tmp_bfd == NULL)
845 {
846 enable_break_failure_warning ();
847 return 0;
848 }
849
850 dsbt_get_initial_loadmaps ();
851 ldm = info->interp_loadmap;
852
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");
856 if (interp_sect)
857 {
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);
865 }
866 interp_sect = bfd_get_section_by_name (tmp_bfd.get (), ".plt");
867 if (interp_sect)
868 {
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 (),
875 interp_sect);
876 }
877
878 addr = gdb_bfd_lookup_symbol (tmp_bfd.get (), cmp_name,
879 "_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 loadmap. */
907 xfree (ldm);
908
909 return ret;
910 }
911
912 /* Tell the user we couldn't set a dynamic linker breakpoint. */
913 enable_break_failure_warning ();
914
915 /* Failure return. */
916 return 0;
917 }
918
919 static void
920 dsbt_relocate_main_executable (void)
921 {
922 struct int_elf32_dsbt_loadmap *ldm;
923 struct cleanup *old_chain;
924 struct section_offsets *new_offsets;
925 int changed;
926 struct obj_section *osect;
927 struct dsbt_info *info = get_dsbt_info ();
928
929 dsbt_get_initial_loadmaps ();
930 ldm = info->exec_loadmap;
931
932 delete info->main_executable_lm_info;
933 info->main_executable_lm_info = new lm_info_dsbt;
934 info->main_executable_lm_info->map = ldm;
935
936 new_offsets = XCNEWVEC (struct section_offsets,
937 symfile_objfile->num_sections);
938 old_chain = make_cleanup (xfree, new_offsets);
939 changed = 0;
940
941 ALL_OBJFILE_OSECTIONS (symfile_objfile, osect)
942 {
943 CORE_ADDR orig_addr, addr, offset;
944 int osect_idx;
945 int seg;
946
947 osect_idx = osect - symfile_objfile->sections;
948
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;
955
956 for (seg = 0; seg < ldm->nsegs; seg++)
957 {
958 if (ldm->segs[seg].p_vaddr <= orig_addr
959 && orig_addr < ldm->segs[seg].p_vaddr + ldm->segs[seg].p_memsz)
960 {
961 new_offsets->offsets[osect_idx]
962 = ldm->segs[seg].addr - ldm->segs[seg].p_vaddr;
963
964 if (new_offsets->offsets[osect_idx] != offset)
965 changed = 1;
966 break;
967 }
968 }
969 }
970
971 if (changed)
972 objfile_relocate (symfile_objfile, new_offsets);
973
974 do_cleanups (old_chain);
975
976 /* Now that symfile_objfile has been relocated, we can compute the
977 GOT value and stash it away. */
978 }
979
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.
983
984 For the DSBT shared library, the main executable needs to be relocated.
985 The shared library breakpoints also need to be enabled. */
986
987 static void
988 dsbt_solib_create_inferior_hook (int from_tty)
989 {
990 /* Relocate main executable. */
991 dsbt_relocate_main_executable ();
992
993 /* Enable shared library breakpoints. */
994 if (!enable_break ())
995 {
996 warning (_("shared library handler failed to enable breakpoint"));
997 return;
998 }
999 }
1000
1001 static void
1002 dsbt_clear_solib (void)
1003 {
1004 struct dsbt_info *info = get_dsbt_info ();
1005
1006 info->lm_base_cache = 0;
1007 info->main_lm_addr = 0;
1008
1009 delete info->main_executable_lm_info;
1010 info->main_executable_lm_info = NULL;
1011 }
1012
1013 static void
1014 dsbt_free_so (struct so_list *so)
1015 {
1016 lm_info_dsbt *li = (lm_info_dsbt *) so->lm_info;
1017
1018 delete li;
1019 }
1020
1021 static void
1022 dsbt_relocate_section_addresses (struct so_list *so,
1023 struct target_section *sec)
1024 {
1025 int seg;
1026 lm_info_dsbt *li = (lm_info_dsbt *) so->lm_info;
1027 int_elf32_dsbt_loadmap *map = li->map;
1028
1029 for (seg = 0; seg < map->nsegs; seg++)
1030 {
1031 if (map->segs[seg].p_vaddr <= sec->addr
1032 && sec->addr < map->segs[seg].p_vaddr + map->segs[seg].p_memsz)
1033 {
1034 CORE_ADDR displ = map->segs[seg].addr - map->segs[seg].p_vaddr;
1035
1036 sec->addr += displ;
1037 sec->endaddr += displ;
1038 break;
1039 }
1040 }
1041 }
1042 static void
1043 show_dsbt_debug (struct ui_file *file, int from_tty,
1044 struct cmd_list_element *c, const char *value)
1045 {
1046 fprintf_filtered (file, _("solib-dsbt debugging is %s.\n"), value);
1047 }
1048
1049 struct target_so_ops dsbt_so_ops;
1050
1051 void
1052 _initialize_dsbt_solib (void)
1053 {
1054 solib_dsbt_pspace_data
1055 = register_program_space_data_with_cleanup (NULL, dsbt_pspace_data_cleanup);
1056
1057 dsbt_so_ops.relocate_section_addresses = dsbt_relocate_section_addresses;
1058 dsbt_so_ops.free_so = dsbt_free_so;
1059 dsbt_so_ops.clear_solib = dsbt_clear_solib;
1060 dsbt_so_ops.solib_create_inferior_hook = dsbt_solib_create_inferior_hook;
1061 dsbt_so_ops.current_sos = dsbt_current_sos;
1062 dsbt_so_ops.open_symbol_file_object = open_symbol_file_object;
1063 dsbt_so_ops.in_dynsym_resolve_code = dsbt_in_dynsym_resolve_code;
1064 dsbt_so_ops.bfd_open = solib_bfd_open;
1065
1066 /* Debug this file's internals. */
1067 add_setshow_zuinteger_cmd ("solib-dsbt", class_maintenance,
1068 &solib_dsbt_debug, _("\
1069 Set internal debugging of shared library code for DSBT ELF."), _("\
1070 Show internal debugging of shared library code for DSBT ELF."), _("\
1071 When non-zero, DSBT solib specific internal debugging is enabled."),
1072 NULL,
1073 show_dsbt_debug,
1074 &setdebuglist, &showdebuglist);
1075 }
target_gdbarch
struct gdbarch * target_gdbarch(void)
Definition: gdbarch.c:5467
dsbt_print_loadmap
static void dsbt_print_loadmap(struct int_elf32_dsbt_loadmap *map)
Definition: solib-dsbt.c:199
ext_link_map::l_prev
ext_ptr l_prev
Definition: solib-dsbt.c:121
extract_typed_address
CORE_ADDR extract_typed_address(const gdb_byte *buf, struct type *type)
Definition: findvar.c:154
section_offsets::offsets
CORE_ADDR offsets[1]
Definition: symtab.h:1273
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
dsbt_info::interp_plt_sect_high
CORE_ADDR interp_plt_sect_high
Definition: solib-dsbt.c:163
RETURN_MASK_ALL
Definition: common-exceptions.h:44
ext_elf32_dsbt_loadmap::version
ext_Elf32_Word version
Definition: solib-dsbt.c:62
dsbt_solib_create_inferior_hook
static void dsbt_solib_create_inferior_hook(int from_tty)
Definition: solib-dsbt.c:988
command.h
xfree
void xfree(void *)
so_list::next
struct so_list * next
Definition: solist.h:44
create_solib_event_breakpoint
struct breakpoint * create_solib_event_breakpoint(struct gdbarch *gdbarch, CORE_ADDR address)
Definition: breakpoint.c:7560
solist.h
cmd_list_element
Definition: cli-decode.h:46
BMSYMBOL_VALUE_ADDRESS
#define BMSYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:691
warning
void warning(const char *fmt,...)
Definition: errors.c:26
target_read_alloc
LONGEST target_read_alloc(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte **buf_p)
Definition: target.c:1918
TARGET_OBJECT_FDPIC
Definition: target.h:187
builtin_type
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition: gdbtypes.c:5217
target_so_ops::relocate_section_addresses
void(* relocate_section_addresses)(struct so_list *so, struct target_section *)
Definition: solist.h:95
lm_info_dsbt::~lm_info_dsbt
~lm_info_dsbt()
Definition: solib-dsbt.c:128
cmp_name
static int cmp_name(const asymbol *sym, const void *data)
Definition: solib-dsbt.c:780
target_so_ops::solib_create_inferior_hook
void(* solib_create_inferior_hook)(int from_tty)
Definition: solist.h:112
target_so_ops::current_sos
struct so_list *(* current_sos)(void)
Definition: solist.h:121
ext_Elf32_Addr
gdb_byte ext_Elf32_Addr[4]
Definition: solib-dsbt.c:47
objfile_relocate
void objfile_relocate(struct objfile *objfile, const struct section_offsets *new_offsets)
Definition: objfiles.c:896
get_dsbt_info
static struct dsbt_info * get_dsbt_info(void)
Definition: solib-dsbt.c:179
enable_break
static int enable_break(void)
Definition: solib-dsbt.c:794
so_list
Definition: solist.h:38
lm_info_dsbt::map
int_elf32_dsbt_loadmap * map
Definition: solib-dsbt.c:134
ALL_OBJFILE_OSECTIONS
#define ALL_OBJFILE_OSECTIONS(objfile, osect)
Definition: objfiles.h:630
lm_info_dsbt
Definition: solib-dsbt.c:126
SO_NAME_MAX_PATH_SIZE
#define SO_NAME_MAX_PATH_SIZE
Definition: solist.h:22
dsbt_info::lm_base_cache
CORE_ADDR lm_base_cache
Definition: solib-dsbt.c:155
cleanup
Definition: cleanups.c:38
lm_addr
static CORE_ADDR lm_addr(struct so_list *so)
Definition: nto-tdep.c:243
_
#define _(String)
Definition: gdb_locale.h:35
target_so_ops
Definition: solist.h:91
gdb_bfd.h
ui_file
Definition: ui-file.h:26
int_elf32_dsbt_loadmap
Definition: solib-dsbt.c:87
defs.h
END_CATCH
#define END_CATCH
Definition: common-exceptions.h:259
int_elf32_dsbt_loadmap::dsbt_table_ptr
CORE_ADDR dsbt_table_ptr
Definition: solib-dsbt.c:91
printf_filtered
void printf_filtered(const char *format,...)
Definition: utils.c:2045
target_so_ops::bfd_open
gdb_bfd_ref_ptr(* bfd_open)(char *pathname)
Definition: solist.h:132
objfiles.h
dsbt_info::interp_plt_sect_low
CORE_ADDR interp_plt_sect_low
Definition: solib-dsbt.c:162
ext_elf32_dsbt_loadseg::p_memsz
ext_Elf32_Word p_memsz
Definition: solib-dsbt.c:57
dsbt_in_dynsym_resolve_code
static int dsbt_in_dynsym_resolve_code(CORE_ADDR pc)
Definition: solib-dsbt.c:757
add_setshow_zuinteger_cmd
void add_setshow_zuinteger_cmd(const char *name, enum command_class theclass, unsigned int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_const_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:792
ext_elf32_dsbt_loadmap::nsegs
ext_Elf32_Word nsegs
Definition: solib-dsbt.c:69
target_so_ops::clear_solib
void(* clear_solib)(void)
Definition: solist.h:109
int_elf32_dsbt_loadmap::segs
struct int_elf32_dsbt_loadseg segs[1]
Definition: solib-dsbt.c:98
XCNEWVEC
#define XCNEWVEC(T, N)
Definition: poison.h:157
int_elf32_dsbt_loadmap::dsbt_index
int dsbt_index
Definition: solib-dsbt.c:94
TRY
#define TRY
Definition: common-exceptions.h:246
ext_elf32_dsbt_loadseg
Definition: solib-dsbt.c:50
symtab.h
decode_loadmap
static struct int_elf32_dsbt_loadmap * decode_loadmap(gdb_byte *buf)
Definition: solib-dsbt.c:227
ext_link_map
Definition: solib-dsbt.c:110
ext_elf32_dsbt_loadmap::dsbt_index
ext_Elf32_Word dsbt_index
Definition: solib-dsbt.c:67
dsbt_info::main_executable_lm_info
struct lm_info_dsbt * main_executable_lm_info
Definition: solib-dsbt.c:145
target_so_ops::in_dynsym_resolve_code
int(* in_dynsym_resolve_code)(CORE_ADDR pc)
Definition: solist.h:129
section_offsets
Definition: symtab.h:1271
gdb::ref_ptr
Definition: gdb_ref_ptr.h:49
ext_Elf32_Word
gdb_byte ext_Elf32_Word[4]
Definition: solib-dsbt.c:48
lm_info_base
Definition: solist.h:34
CATCH
#define CATCH(EXCEPTION, MASK)
Definition: common-exceptions.h:254
dsbt_info::interp_text_sect_high
CORE_ADDR interp_text_sect_high
Definition: solib-dsbt.c:161
current_target
struct target_ops current_target
dsbt_relocate_section_addresses
static void dsbt_relocate_section_addresses(struct so_list *so, struct target_section *sec)
Definition: solib-dsbt.c:1022
exec_bfd
#define exec_bfd
Definition: exec.h:33
fprintf_filtered
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2008
extract_unsigned_integer
static ULONGEST extract_unsigned_integer(const gdb_byte *addr, int len, enum bfd_endian byte_order)
Definition: defs.h:577
current_target_sections
#define current_target_sections
Definition: progspace.h:235
bound_minimal_symbol
Definition: minsyms.h:29
show_dsbt_debug
static void show_dsbt_debug(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: solib-dsbt.c:1043
GOT_MODULE_OFFSET
#define GOT_MODULE_OFFSET
Definition: solib-dsbt.c:33
fprintf_unfiltered
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2018
ext_elf32_dsbt_loadaddr
Definition: solib-dsbt.c:105
dsbt_info::interp_loadmap
struct int_elf32_dsbt_loadmap * interp_loadmap
Definition: solib-dsbt.c:152
so_list::so_original_name
char so_original_name[SO_NAME_MAX_PATH_SIZE]
Definition: solist.h:57
gdbarch_byte_order
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1509
inferior.h
make_cleanup
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:116
solib_dsbt_debug
static unsigned int solib_dsbt_debug
Definition: solib-dsbt.c:36
ANOFFSET
#define ANOFFSET(secoff, whichone)
Definition: symtab.h:1276
version
const char version[]
Definition: version.c:2
type
Definition: gdbtypes.h:749
so_list::so_name
char so_name[SO_NAME_MAX_PATH_SIZE]
Definition: solist.h:60
language.h
ext_elf32_dsbt_loadseg::p_vaddr
ext_Elf32_Addr p_vaddr
Definition: solib-dsbt.c:55
ext_ptr
gdb_byte ext_ptr[4]
Definition: solib-dsbt.c:103
dsbt_so_ops
struct target_so_ops dsbt_so_ops
Definition: solib-dsbt.c:1049
solib.h
symfile_objfile
#define symfile_objfile
Definition: progspace.h:227
target_section::endaddr
CORE_ADDR endaddr
Definition: target.h:2318
target_has_execution
#define target_has_execution
Definition: target.h:1756
setdebuglist
struct cmd_list_element * setdebuglist
Definition: cli-cmds.c:153
gdb_bfd_lookup_symbol
CORE_ADDR gdb_bfd_lookup_symbol(bfd *abfd, int(*match_sym)(const asymbol *, const void *), const void *data)
Definition: solib.c:1582
target_section::the_bfd_section
struct bfd_section * the_bfd_section
Definition: target.h:2320
xmalloc
void * xmalloc(YYSIZE_T)
ext_link_map::l_addr
struct ext_elf32_dsbt_loadaddr l_addr
Definition: solib-dsbt.c:112
int_elf32_dsbt_loadseg::p_memsz
long p_memsz
Definition: solib-dsbt.c:84
dsbt_get_initial_loadmaps
static void dsbt_get_initial_loadmaps(void)
Definition: solib-dsbt.c:293
target_section::addr
CORE_ADDR addr
Definition: target.h:2317
displacement_from_map
static CORE_ADDR displacement_from_map(struct int_elf32_dsbt_loadmap *map, CORE_ADDR addr)
Definition: solib-dsbt.c:523
value
Definition: value.c:169
ext_link_map::l_next
ext_ptr l_next
Definition: solib-dsbt.c:121
solib_dsbt_pspace_data
static const struct program_space_data * solib_dsbt_pspace_data
Definition: solib-dsbt.c:167
scan_dyntag
static int scan_dyntag(int dyntag, bfd *abfd, CORE_ADDR *ptr)
Definition: solib-dsbt.c:415
target_so_ops::open_symbol_file_object
int(* open_symbol_file_object)(int from_ttyp)
Definition: solist.h:125
enable_break_failure_warning
static void enable_break_failure_warning(void)
Definition: solib-dsbt.c:770
obj_section
Definition: objfiles.h:123
gdb_byte
bfd_byte gdb_byte
Definition: common-types.h:38
ext_elf32_dsbt_loadaddr::map
ext_ptr map
Definition: solib-dsbt.c:107
hex_string_custom
char * hex_string_custom(LONGEST num, int width)
Definition: print-utils.c:231
XCNEW
#define XCNEW(T)
Definition: poison.h:121
gdbcore.h
interp_plt_sect_high
static CORE_ADDR interp_plt_sect_high
Definition: solib-frv.c:449
ext_elf32_dsbt_loadmap::segs
struct ext_elf32_dsbt_loadseg segs[1]
Definition: solib-dsbt.c:71
int_elf32_dsbt_loadseg::addr
CORE_ADDR addr
Definition: solib-dsbt.c:80
target_read_memory
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: target.c:1370
builtin_type::builtin_data_ptr
struct type * builtin_data_ptr
Definition: gdbtypes.h:1554
in_plt_section
static int in_plt_section(CORE_ADDR pc)
Definition: objfiles.h:542
lm_base
static CORE_ADDR lm_base(void)
Definition: solib-dsbt.c:548
bound_minimal_symbol::minsym
struct minimal_symbol * minsym
Definition: minsyms.h:34
dsbt_info::main_lm_addr
CORE_ADDR main_lm_addr
Definition: solib-dsbt.c:158
target_so_ops::free_so
void(* free_so)(struct so_list *so)
Definition: solist.h:100
safe_strerror
char * safe_strerror(int)
Definition: mingw-strerror.c:32
obj_section_addr
#define obj_section_addr(s)
Definition: objfiles.h:140
offset
int offset
Definition: agent.c:65
ext_elf32_dsbt_loadmap
Definition: solib-dsbt.c:60
target_section
Definition: target.h:2315
gdb::ref_ptr::get
T * get() const
Definition: gdb_ref_ptr.h:130
TIC6X_PTR_SIZE
Definition: solib-dsbt.c:39
dsbt_free_so
static void dsbt_free_so(struct so_list *so)
Definition: solib-dsbt.c:1014
print_core_address
const char * print_core_address(struct gdbarch *gdbarch, CORE_ADDR address)
Definition: utils.c:2766
current_program_space
struct program_space * current_program_space
Definition: progspace.c:35
int_elf32_dsbt_loadmap::dsbt_size
int dsbt_size
Definition: solib-dsbt.c:94
ext_elf32_dsbt_loadmap::dsbt_table_ptr
ext_Elf32_Word dsbt_table_ptr
Definition: solib-dsbt.c:65
ext_elf32_dsbt_loadmap::dsbt_size
ext_Elf32_Word dsbt_size
Definition: solib-dsbt.c:66
dsbt_info::interp_text_sect_low
CORE_ADDR interp_text_sect_low
Definition: solib-dsbt.c:160
open_symbol_file_object
static int open_symbol_file_object(int from_tty)
Definition: solib-dsbt.c:513
dsbt_pspace_data_cleanup
static void dsbt_pspace_data_cleanup(struct program_space *pspace, void *arg)
Definition: solib-dsbt.c:170
int_elf32_dsbt_loadseg
Definition: solib-dsbt.c:77
gdb_stdlog
#define gdb_stdlog
Definition: utils.h:349
showdebuglist
struct cmd_list_element * showdebuglist
Definition: cli-cmds.c:155
_initialize_dsbt_solib
void _initialize_dsbt_solib(void)
Definition: solib-dsbt.c:1052
ext_link_map::l_name
ext_ptr l_name
Definition: solib-dsbt.c:115
core_bfd
bfd * core_bfd
Definition: corefile.c:54
solib_bfd_open
gdb_bfd_ref_ptr solib_bfd_open(char *pathname)
Definition: solib.c:496
int_elf32_dsbt_loadmap::version
int version
Definition: solib-dsbt.c:90
class_maintenance
Definition: command.h:43
ext_Elf32_Half
gdb_byte ext_Elf32_Half[2]
Definition: solib-dsbt.c:46
dsbt_current_sos
static struct so_list * dsbt_current_sos(void)
Definition: solib-dsbt.c:628
int_elf32_dsbt_loadseg::p_vaddr
CORE_ADDR p_vaddr
Definition: solib-dsbt.c:82
interp_text_sect_high
static CORE_ADDR interp_text_sect_high
Definition: solib-frv.c:447
so_list::lm_info
lm_info_base * lm_info
Definition: solist.h:50
dsbt_info
Definition: solib-dsbt.c:139
lookup_minimal_symbol
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition: minsyms.c:311
ext_link_map::l_ld
ext_ptr l_ld
Definition: solib-dsbt.c:118
int_elf32_dsbt_loadmap::nsegs
int nsegs
Definition: solib-dsbt.c:96
target_read_string
int target_read_string(CORE_ADDR memaddr, char **string, int len, int *errnop)
Definition: target.c:907
gdbcmd.h
dsbt_info::exec_loadmap
struct int_elf32_dsbt_loadmap * exec_loadmap
Definition: solib-dsbt.c:151
error
void error(const char *fmt,...)
Definition: errors.c:38
fetch_loadmap
static struct int_elf32_dsbt_loadmap * fetch_loadmap(CORE_ADDR ldmaddr)
Definition: solib-dsbt.c:326
ext_elf32_dsbt_loadseg::addr
ext_Elf32_Addr addr
Definition: solib-dsbt.c:53
do_cleanups
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:174
program_space
Definition: progspace.h:137
dsbt_relocate_main_executable
static void dsbt_relocate_main_executable(void)
Definition: solib-dsbt.c:920
dsbt_clear_solib
static void dsbt_clear_solib(void)
Definition: solib-dsbt.c:1002