gdb/solib-dsbt.c

   1 /* Handle TIC6X (DSBT) shared libraries for GDB, the GNU Debugger.
   2    Copyright (C) 2010-2017 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 }