gdb/solib-dsbt.c

   1 /* Handle TIC6X (DSBT) shared libraries for GDB, the GNU Debugger.
   2    Copyright (C) 2010-2016 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
 127 {
 128   /* The loadmap, digested into an easier to use form.  */
 129   struct int_elf32_dsbt_loadmap *map;
 130 };
 131
 132 /* Per pspace dsbt specific data.  */
 133
 134 struct dsbt_info
 135 {
 136   /* The load map, got value, etc. are not available from the chain
 137      of loaded shared objects.  ``main_executable_lm_info'' provides
 138      a way to get at this information so that it doesn't need to be
 139      frequently recomputed.  Initialized by dsbt_relocate_main_executable.  */
 140   struct lm_info *main_executable_lm_info;
 141
 142   /* Load maps for the main executable and the interpreter.  These are obtained
 143      from ptrace.  They are the starting point for getting into the program,
 144      and are required to find the solib list with the individual load maps for
 145      each module.  */
 146   struct int_elf32_dsbt_loadmap *exec_loadmap;
 147   struct int_elf32_dsbt_loadmap *interp_loadmap;
 148
 149   /* Cached value for lm_base, below.  */
 150   CORE_ADDR lm_base_cache;
 151
 152   /* Link map address for main module.  */
 153   CORE_ADDR main_lm_addr;
 154
 155   CORE_ADDR interp_text_sect_low;
 156   CORE_ADDR interp_text_sect_high;
 157   CORE_ADDR interp_plt_sect_low;
 158   CORE_ADDR interp_plt_sect_high;
 159 };
 160
 161 /* Per-program-space data key.  */
 162 static const struct program_space_data *solib_dsbt_pspace_data;
 163
 164 static void
 165 dsbt_pspace_data_cleanup (struct program_space *pspace, void *arg)
 166 {
 167   xfree (arg);
 168 }
 169
 170 /* Get the current dsbt data.  If none is found yet, add it now.  This
 171    function always returns a valid object.  */
 172
 173 static struct dsbt_info *
 174 get_dsbt_info (void)
 175 {
 176   struct dsbt_info *info;
 177
 178   info = (struct dsbt_info *) program_space_data (current_program_space,
 179                                                   solib_dsbt_pspace_data);
 180   if (info != NULL)
 181     return info;
 182
 183   info = XCNEW (struct dsbt_info);
 184   set_program_space_data (current_program_space, solib_dsbt_pspace_data, info);
 185
 186   info->lm_base_cache = 0;
 187   info->main_lm_addr = 0;
 188
 189   return info;
 190 }
 191
 192
 193 static void
 194 dsbt_print_loadmap (struct int_elf32_dsbt_loadmap *map)
 195 {
 196   int i;
 197
 198   if (map == NULL)
 199     printf_filtered ("(null)\n");
 200   else if (map->version != 0)
 201     printf_filtered (_("Unsupported map version: %d\n"), map->version);
 202   else
 203     {
 204       printf_filtered ("version %d\n", map->version);
 205
 206       for (i = 0; i < map->nsegs; i++)
 207         printf_filtered ("%s:%s -> %s:%s\n",
 208                          print_core_address (target_gdbarch (),
 209                                              map->segs[i].p_vaddr),
 210                          print_core_address (target_gdbarch (),
 211                                              map->segs[i].p_vaddr
 212                                              + map->segs[i].p_memsz),
 213                          print_core_address (target_gdbarch (), map->segs[i].addr),
 214                          print_core_address (target_gdbarch (), map->segs[i].addr
 215                                              + map->segs[i].p_memsz));
 216     }
 217 }
 218
 219 /* Decode int_elf32_dsbt_loadmap from BUF.  */
 220
 221 static struct int_elf32_dsbt_loadmap *
 222 decode_loadmap (gdb_byte *buf)
 223 {
 224   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 225   struct ext_elf32_dsbt_loadmap *ext_ldmbuf;
 226   struct int_elf32_dsbt_loadmap *int_ldmbuf;
 227
 228   int version, seg, nsegs;
 229   int int_ldmbuf_size;
 230
 231   ext_ldmbuf = (struct ext_elf32_dsbt_loadmap *) buf;
 232
 233   /* Extract the version.  */
 234   version = extract_unsigned_integer (ext_ldmbuf->version,
 235                                       sizeof ext_ldmbuf->version,
 236                                       byte_order);
 237   if (version != 0)
 238     {
 239       /* We only handle version 0.  */
 240       return NULL;
 241     }
 242
 243   /* Extract the number of segments.  */
 244   nsegs = extract_unsigned_integer (ext_ldmbuf->nsegs,
 245                                     sizeof ext_ldmbuf->nsegs,
 246                                     byte_order);
 247
 248   if (nsegs <= 0)
 249     return NULL;
 250
 251   /* Allocate space into which to put information extract from the
 252      external loadsegs.  I.e, allocate the internal loadsegs.  */
 253   int_ldmbuf_size = (sizeof (struct int_elf32_dsbt_loadmap)
 254                      + (nsegs - 1) * sizeof (struct int_elf32_dsbt_loadseg));
 255   int_ldmbuf = (struct int_elf32_dsbt_loadmap *) xmalloc (int_ldmbuf_size);
 256
 257   /* Place extracted information in internal structs.  */
 258   int_ldmbuf->version = version;
 259   int_ldmbuf->nsegs = nsegs;
 260   for (seg = 0; seg < nsegs; seg++)
 261     {
 262       int_ldmbuf->segs[seg].addr
 263         = extract_unsigned_integer (ext_ldmbuf->segs[seg].addr,
 264                                     sizeof (ext_ldmbuf->segs[seg].addr),
 265                                     byte_order);
 266       int_ldmbuf->segs[seg].p_vaddr
 267         = extract_unsigned_integer (ext_ldmbuf->segs[seg].p_vaddr,
 268                                     sizeof (ext_ldmbuf->segs[seg].p_vaddr),
 269                                     byte_order);
 270       int_ldmbuf->segs[seg].p_memsz
 271         = extract_unsigned_integer (ext_ldmbuf->segs[seg].p_memsz,
 272                                     sizeof (ext_ldmbuf->segs[seg].p_memsz),
 273                                     byte_order);
 274     }
 275
 276   xfree (ext_ldmbuf);
 277   return int_ldmbuf;
 278 }
 279
 280
 281 static struct dsbt_info *get_dsbt_info (void);
 282
 283 /* Interrogate the Linux kernel to find out where the program was loaded.
 284    There are two load maps; one for the executable and one for the
 285    interpreter (only in the case of a dynamically linked executable).  */
 286
 287 static void
 288 dsbt_get_initial_loadmaps (void)
 289 {
 290   gdb_byte *buf;
 291   struct dsbt_info *info = get_dsbt_info ();
 292
 293   if (0 >= target_read_alloc (&current_target, TARGET_OBJECT_FDPIC,
 294                               "exec", &buf))
 295     {
 296       info->exec_loadmap = NULL;
 297       error (_("Error reading DSBT exec loadmap"));
 298     }
 299   info->exec_loadmap = decode_loadmap (buf);
 300   if (solib_dsbt_debug)
 301     dsbt_print_loadmap (info->exec_loadmap);
 302
 303   if (0 >= target_read_alloc (&current_target, TARGET_OBJECT_FDPIC,
 304                               "interp", &buf))
 305     {
 306       info->interp_loadmap = NULL;
 307       error (_("Error reading DSBT interp loadmap"));
 308     }
 309   info->interp_loadmap = decode_loadmap (buf);
 310   if (solib_dsbt_debug)
 311     dsbt_print_loadmap (info->interp_loadmap);
 312 }
 313
 314 /* Given address LDMADDR, fetch and decode the loadmap at that address.
 315    Return NULL if there is a problem reading the target memory or if
 316    there doesn't appear to be a loadmap at the given address.  The
 317    allocated space (representing the loadmap) returned by this
 318    function may be freed via a single call to xfree.  */
 319
 320 static struct int_elf32_dsbt_loadmap *
 321 fetch_loadmap (CORE_ADDR ldmaddr)
 322 {
 323   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 324   struct ext_elf32_dsbt_loadmap ext_ldmbuf_partial;
 325   struct ext_elf32_dsbt_loadmap *ext_ldmbuf;
 326   struct int_elf32_dsbt_loadmap *int_ldmbuf;
 327   int ext_ldmbuf_size, int_ldmbuf_size;
 328   int version, seg, nsegs;
 329
 330   /* Fetch initial portion of the loadmap.  */
 331   if (target_read_memory (ldmaddr, (gdb_byte *) &ext_ldmbuf_partial,
 332                           sizeof ext_ldmbuf_partial))
 333     {
 334       /* Problem reading the target's memory.  */
 335       return NULL;
 336     }
 337
 338   /* Extract the version.  */
 339   version = extract_unsigned_integer (ext_ldmbuf_partial.version,
 340                                       sizeof ext_ldmbuf_partial.version,
 341                                       byte_order);
 342   if (version != 0)
 343     {
 344       /* We only handle version 0.  */
 345       return NULL;
 346     }
 347
 348   /* Extract the number of segments.  */
 349   nsegs = extract_unsigned_integer (ext_ldmbuf_partial.nsegs,
 350                                     sizeof ext_ldmbuf_partial.nsegs,
 351                                     byte_order);
 352
 353   if (nsegs <= 0)
 354     return NULL;
 355
 356   /* Allocate space for the complete (external) loadmap.  */
 357   ext_ldmbuf_size = sizeof (struct ext_elf32_dsbt_loadmap)
 358     + (nsegs - 1) * sizeof (struct ext_elf32_dsbt_loadseg);
 359   ext_ldmbuf = (struct ext_elf32_dsbt_loadmap *) xmalloc (ext_ldmbuf_size);
 360
 361   /* Copy over the portion of the loadmap that's already been read.  */
 362   memcpy (ext_ldmbuf, &ext_ldmbuf_partial, sizeof ext_ldmbuf_partial);
 363
 364   /* Read the rest of the loadmap from the target.  */
 365   if (target_read_memory (ldmaddr + sizeof ext_ldmbuf_partial,
 366                           (gdb_byte *) ext_ldmbuf + sizeof ext_ldmbuf_partial,
 367                           ext_ldmbuf_size - sizeof ext_ldmbuf_partial))
 368     {
 369       /* Couldn't read rest of the loadmap.  */
 370       xfree (ext_ldmbuf);
 371       return NULL;
 372     }
 373
 374   /* Allocate space into which to put information extract from the
 375      external loadsegs.  I.e, allocate the internal loadsegs.  */
 376   int_ldmbuf_size = sizeof (struct int_elf32_dsbt_loadmap)
 377     + (nsegs - 1) * sizeof (struct int_elf32_dsbt_loadseg);
 378   int_ldmbuf = (struct int_elf32_dsbt_loadmap *) xmalloc (int_ldmbuf_size);
 379
 380   /* Place extracted information in internal structs.  */
 381   int_ldmbuf->version = version;
 382   int_ldmbuf->nsegs = nsegs;
 383   for (seg = 0; seg < nsegs; seg++)
 384     {
 385       int_ldmbuf->segs[seg].addr
 386         = extract_unsigned_integer (ext_ldmbuf->segs[seg].addr,
 387                                     sizeof (ext_ldmbuf->segs[seg].addr),
 388                                     byte_order);
 389       int_ldmbuf->segs[seg].p_vaddr
 390         = extract_unsigned_integer (ext_ldmbuf->segs[seg].p_vaddr,
 391                                     sizeof (ext_ldmbuf->segs[seg].p_vaddr),
 392                                     byte_order);
 393       int_ldmbuf->segs[seg].p_memsz
 394         = extract_unsigned_integer (ext_ldmbuf->segs[seg].p_memsz,
 395                                     sizeof (ext_ldmbuf->segs[seg].p_memsz),
 396                                     byte_order);
 397     }
 398
 399   xfree (ext_ldmbuf);
 400   return int_ldmbuf;
 401 }
 402
 403 static void dsbt_relocate_main_executable (void);
 404 static int enable_break (void);
 405
 406 /* Scan for DYNTAG in .dynamic section of ABFD. If DYNTAG is found 1 is
 407    returned and the corresponding PTR is set.  */
 408
 409 static int
 410 scan_dyntag (int dyntag, bfd *abfd, CORE_ADDR *ptr)
 411 {
 412   int arch_size, step, sect_size;
 413   long dyn_tag;
 414   CORE_ADDR dyn_ptr, dyn_addr;
 415   gdb_byte *bufend, *bufstart, *buf;
 416   Elf32_External_Dyn *x_dynp_32;
 417   Elf64_External_Dyn *x_dynp_64;
 418   struct bfd_section *sect;
 419   struct target_section *target_section;
 420
 421   if (abfd == NULL)
 422     return 0;
 423
 424   if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
 425     return 0;
 426
 427   arch_size = bfd_get_arch_size (abfd);
 428   if (arch_size == -1)
 429     return 0;
 430
 431   /* Find the start address of the .dynamic section.  */
 432   sect = bfd_get_section_by_name (abfd, ".dynamic");
 433   if (sect == NULL)
 434     return 0;
 435
 436   for (target_section = current_target_sections->sections;
 437        target_section < current_target_sections->sections_end;
 438        target_section++)
 439     if (sect == target_section->the_bfd_section)
 440       break;
 441   if (target_section < current_target_sections->sections_end)
 442     dyn_addr = target_section->addr;
 443   else
 444     {
 445       /* ABFD may come from OBJFILE acting only as a symbol file without being
 446          loaded into the target (see add_symbol_file_command).  This case is
 447          such fallback to the file VMA address without the possibility of
 448          having the section relocated to its actual in-memory address.  */
 449
 450       dyn_addr = bfd_section_vma (abfd, sect);
 451     }
 452
 453   /* Read in .dynamic from the BFD.  We will get the actual value
 454      from memory later.  */
 455   sect_size = bfd_section_size (abfd, sect);
 456   buf = bufstart = (gdb_byte *) alloca (sect_size);
 457   if (!bfd_get_section_contents (abfd, sect,
 458                                  buf, 0, sect_size))
 459     return 0;
 460
 461   /* Iterate over BUF and scan for DYNTAG.  If found, set PTR and return.  */
 462   step = (arch_size == 32) ? sizeof (Elf32_External_Dyn)
 463                            : sizeof (Elf64_External_Dyn);
 464   for (bufend = buf + sect_size;
 465        buf < bufend;
 466        buf += step)
 467   {
 468     if (arch_size == 32)
 469       {
 470         x_dynp_32 = (Elf32_External_Dyn *) buf;
 471         dyn_tag = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp_32->d_tag);
 472         dyn_ptr = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp_32->d_un.d_ptr);
 473       }
 474     else
 475       {
 476         x_dynp_64 = (Elf64_External_Dyn *) buf;
 477         dyn_tag = bfd_h_get_64 (abfd, (bfd_byte *) x_dynp_64->d_tag);
 478         dyn_ptr = bfd_h_get_64 (abfd, (bfd_byte *) x_dynp_64->d_un.d_ptr);
 479       }
 480      if (dyn_tag == DT_NULL)
 481        return 0;
 482      if (dyn_tag == dyntag)
 483        {
 484          /* If requested, try to read the runtime value of this .dynamic
 485             entry.  */
 486          if (ptr)
 487            {
 488              struct type *ptr_type;
 489              gdb_byte ptr_buf[8];
 490              CORE_ADDR ptr_addr;
 491
 492              ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
 493              ptr_addr = dyn_addr + (buf - bufstart) + arch_size / 8;
 494              if (target_read_memory (ptr_addr, ptr_buf, arch_size / 8) == 0)
 495                dyn_ptr = extract_typed_address (ptr_buf, ptr_type);
 496              *ptr = dyn_ptr;
 497            }
 498          return 1;
 499        }
 500   }
 501
 502   return 0;
 503 }
 504
 505 /* If no open symbol file, attempt to locate and open the main symbol
 506    file.
 507
 508    If FROM_TTYP dereferences to a non-zero integer, allow messages to
 509    be printed.  This parameter is a pointer rather than an int because
 510    open_symbol_file_object is called via catch_errors and
 511    catch_errors requires a pointer argument. */
 512
 513 static int
 514 open_symbol_file_object (void *from_ttyp)
 515 {
 516   /* Unimplemented.  */
 517   return 0;
 518 }
 519
 520 /* Given a loadmap and an address, return the displacement needed
 521    to relocate the address.  */
 522
 523 static CORE_ADDR
 524 displacement_from_map (struct int_elf32_dsbt_loadmap *map,
 525                        CORE_ADDR addr)
 526 {
 527   int seg;
 528
 529   for (seg = 0; seg < map->nsegs; seg++)
 530     if (map->segs[seg].p_vaddr <= addr
 531         && addr < map->segs[seg].p_vaddr + map->segs[seg].p_memsz)
 532       return map->segs[seg].addr - map->segs[seg].p_vaddr;
 533
 534   return 0;
 535 }
 536
 537 /* Return the address from which the link map chain may be found.  On
 538    DSBT, a pointer to the start of the link map will be located at the
 539    word found at base of GOT + GOT_MODULE_OFFSET.
 540
 541    The base of GOT may be found in a number of ways.  Assuming that the
 542    main executable has already been relocated,
 543    1 The easiest way to find this value is to look up the address of
 544    _GLOBAL_OFFSET_TABLE_.
 545    2 The other way is to look for tag DT_PLTGOT, which contains the virtual
 546    address of Global Offset Table.  .*/
 547
 548 static CORE_ADDR
 549 lm_base (void)
 550 {
 551   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 552   struct bound_minimal_symbol got_sym;
 553   CORE_ADDR addr;
 554   gdb_byte buf[TIC6X_PTR_SIZE];
 555   struct dsbt_info *info = get_dsbt_info ();
 556
 557   /* One of our assumptions is that the main executable has been relocated.
 558      Bail out if this has not happened.  (Note that post_create_inferior
 559      in infcmd.c will call solib_add prior to solib_create_inferior_hook.
 560      If we allow this to happen, lm_base_cache will be initialized with
 561      a bogus value.  */
 562   if (info->main_executable_lm_info == 0)
 563     return 0;
 564
 565   /* If we already have a cached value, return it.  */
 566   if (info->lm_base_cache)
 567     return info->lm_base_cache;
 568
 569   got_sym = lookup_minimal_symbol ("_GLOBAL_OFFSET_TABLE_", NULL,
 570                                    symfile_objfile);
 571
 572   if (got_sym.minsym != 0)
 573     {
 574       addr = BMSYMBOL_VALUE_ADDRESS (got_sym);
 575       if (solib_dsbt_debug)
 576         fprintf_unfiltered (gdb_stdlog,
 577                             "lm_base: get addr %x by _GLOBAL_OFFSET_TABLE_.\n",
 578                             (unsigned int) addr);
 579     }
 580   else if (scan_dyntag (DT_PLTGOT, exec_bfd, &addr))
 581     {
 582       struct int_elf32_dsbt_loadmap *ldm;
 583
 584       dsbt_get_initial_loadmaps ();
 585       ldm = info->exec_loadmap;
 586       addr += displacement_from_map (ldm, addr);
 587       if (solib_dsbt_debug)
 588         fprintf_unfiltered (gdb_stdlog,
 589                             "lm_base: get addr %x by DT_PLTGOT.\n",
 590                             (unsigned int) addr);
 591     }
 592   else
 593     {
 594       if (solib_dsbt_debug)
 595         fprintf_unfiltered (gdb_stdlog,
 596                             "lm_base: _GLOBAL_OFFSET_TABLE_ not found.\n");
 597       return 0;
 598     }
 599   addr += GOT_MODULE_OFFSET;
 600
 601   if (solib_dsbt_debug)
 602     fprintf_unfiltered (gdb_stdlog,
 603                         "lm_base: _GLOBAL_OFFSET_TABLE_ + %d = %s\n",
 604                         GOT_MODULE_OFFSET, hex_string_custom (addr, 8));
 605
 606   if (target_read_memory (addr, buf, sizeof buf) != 0)
 607     return 0;
 608   info->lm_base_cache = extract_unsigned_integer (buf, sizeof buf, byte_order);
 609
 610   if (solib_dsbt_debug)
 611     fprintf_unfiltered (gdb_stdlog,
 612                         "lm_base: lm_base_cache = %s\n",
 613                         hex_string_custom (info->lm_base_cache, 8));
 614
 615   return info->lm_base_cache;
 616 }
 617
 618
 619 /* Build a list of `struct so_list' objects describing the shared
 620    objects currently loaded in the inferior.  This list does not
 621    include an entry for the main executable file.
 622
 623    Note that we only gather information directly available from the
 624    inferior --- we don't examine any of the shared library files
 625    themselves.  The declaration of `struct so_list' says which fields
 626    we provide values for.  */
 627
 628 static struct so_list *
 629 dsbt_current_sos (void)
 630 {
 631   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 632   CORE_ADDR lm_addr;
 633   struct so_list *sos_head = NULL;
 634   struct so_list **sos_next_ptr = &sos_head;
 635   struct dsbt_info *info = get_dsbt_info ();
 636
 637   /* Make sure that the main executable has been relocated.  This is
 638      required in order to find the address of the global offset table,
 639      which in turn is used to find the link map info.  (See lm_base
 640      for details.)
 641
 642      Note that the relocation of the main executable is also performed
 643      by solib_create_inferior_hook, however, in the case of core
 644      files, this hook is called too late in order to be of benefit to
 645      solib_add.  solib_add eventually calls this function,
 646      dsbt_current_sos, and also precedes the call to
 647      solib_create_inferior_hook.   (See post_create_inferior in
 648      infcmd.c.)  */
 649   if (info->main_executable_lm_info == 0 && core_bfd != NULL)
 650     dsbt_relocate_main_executable ();
 651
 652   /* Locate the address of the first link map struct.  */
 653   lm_addr = lm_base ();
 654
 655   /* We have at least one link map entry.  Fetch the the lot of them,
 656      building the solist chain.  */
 657   while (lm_addr)
 658     {
 659       struct ext_link_map lm_buf;
 660       ext_Elf32_Word indexword;
 661       CORE_ADDR map_addr;
 662       int dsbt_index;
 663       int ret;
 664
 665       if (solib_dsbt_debug)
 666         fprintf_unfiltered (gdb_stdlog,
 667                             "current_sos: reading link_map entry at %s\n",
 668                             hex_string_custom (lm_addr, 8));
 669
 670       ret = target_read_memory (lm_addr, (gdb_byte *) &lm_buf, sizeof (lm_buf));
 671       if (ret)
 672         {
 673           warning (_("dsbt_current_sos: Unable to read link map entry."
 674                      "  Shared object chain may be incomplete."));
 675           break;
 676         }
 677
 678       /* Fetch the load map address.  */
 679       map_addr = extract_unsigned_integer (lm_buf.l_addr.map,
 680                                            sizeof lm_buf.l_addr.map,
 681                                            byte_order);
 682
 683       ret = target_read_memory (map_addr + 12, (gdb_byte *) &indexword,
 684                                 sizeof indexword);
 685       if (ret)
 686         {
 687           warning (_("dsbt_current_sos: Unable to read dsbt index."
 688                      "  Shared object chain may be incomplete."));
 689           break;
 690         }
 691       dsbt_index = extract_unsigned_integer (indexword, sizeof indexword,
 692                                              byte_order);
 693
 694       /* If the DSBT index is zero, then we're looking at the entry
 695          for the main executable.  By convention, we don't include
 696          this in the list of shared objects.  */
 697       if (dsbt_index != 0)
 698         {
 699           int errcode;
 700           char *name_buf;
 701           struct int_elf32_dsbt_loadmap *loadmap;
 702           struct so_list *sop;
 703           CORE_ADDR addr;
 704
 705           loadmap = fetch_loadmap (map_addr);
 706           if (loadmap == NULL)
 707             {
 708               warning (_("dsbt_current_sos: Unable to fetch load map."
 709                          "  Shared object chain may be incomplete."));
 710               break;
 711             }
 712
 713           sop = XCNEW (struct so_list);
 714           sop->lm_info = XCNEW (struct lm_info);
 715           sop->lm_info->map = loadmap;
 716           /* Fetch the name.  */
 717           addr = extract_unsigned_integer (lm_buf.l_name,
 718                                            sizeof (lm_buf.l_name),
 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       bfd *tmp_bfd = NULL;
 820       CORE_ADDR addr;
 821       struct int_elf32_dsbt_loadmap *ldm;
 822       int ret;
 823
 824       /* Read the contents of the .interp section into a local buffer;
 825          the contents specify the dynamic linker this program uses.  */
 826       interp_sect_size = bfd_section_size (exec_bfd, interp_sect);
 827       buf = (char *) alloca (interp_sect_size);
 828       bfd_get_section_contents (exec_bfd, interp_sect,
 829                                 buf, 0, interp_sect_size);
 830
 831       /* Now we need to figure out where the dynamic linker was
 832          loaded so that we can load its symbols and place a breakpoint
 833          in the dynamic linker itself.  */
 834
 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, ".text");
 856       if (interp_sect)
 857         {
 858           info->interp_text_sect_low
 859             = bfd_section_vma (tmp_bfd, 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, interp_sect);
 865         }
 866       interp_sect = bfd_get_section_by_name (tmp_bfd, ".plt");
 867       if (interp_sect)
 868         {
 869           info->interp_plt_sect_low =
 870             bfd_section_vma (tmp_bfd, 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, interp_sect);
 875         }
 876
 877       addr = gdb_bfd_lookup_symbol (tmp_bfd, cmp_name, "_dl_debug_state");
 878       if (addr != 0)
 879         {
 880           if (solib_dsbt_debug)
 881             fprintf_unfiltered (gdb_stdlog,
 882                                 "enable_break: _dl_debug_state (prior to relocation) = %s\n",
 883                                 hex_string_custom (addr, 8));
 884           addr += displacement_from_map (ldm, addr);
 885
 886           if (solib_dsbt_debug)
 887             fprintf_unfiltered (gdb_stdlog,
 888                                 "enable_break: _dl_debug_state (after relocation) = %s\n",
 889                                 hex_string_custom (addr, 8));
 890
 891           /* Now (finally!) create the solib breakpoint.  */
 892           create_solib_event_breakpoint (target_gdbarch (), addr);
 893
 894           ret = 1;
 895         }
 896       else
 897         {
 898           if (solib_dsbt_debug)
 899             fprintf_unfiltered (gdb_stdlog,
 900                                 "enable_break: _dl_debug_state is not found\n");
 901           ret = 0;
 902         }
 903
 904       /* We're done with the temporary bfd.  */
 905       gdb_bfd_unref (tmp_bfd);
 906
 907       /* We're also done with the loadmap.  */
 908       xfree (ldm);
 909
 910       return ret;
 911     }
 912
 913   /* Tell the user we couldn't set a dynamic linker breakpoint.  */
 914   enable_break_failure_warning ();
 915
 916   /* Failure return.  */
 917   return 0;
 918 }
 919
 920 static void
 921 dsbt_relocate_main_executable (void)
 922 {
 923   struct int_elf32_dsbt_loadmap *ldm;
 924   struct cleanup *old_chain;
 925   struct section_offsets *new_offsets;
 926   int changed;
 927   struct obj_section *osect;
 928   struct dsbt_info *info = get_dsbt_info ();
 929
 930   dsbt_get_initial_loadmaps ();
 931   ldm = info->exec_loadmap;
 932
 933   xfree (info->main_executable_lm_info);
 934   info->main_executable_lm_info = XCNEW (struct lm_info);
 935   info->main_executable_lm_info->map = ldm;
 936
 937   new_offsets = XCNEWVEC (struct section_offsets,
 938                           symfile_objfile->num_sections);
 939   old_chain = make_cleanup (xfree, new_offsets);
 940   changed = 0;
 941
 942   ALL_OBJFILE_OSECTIONS (symfile_objfile, osect)
 943     {
 944       CORE_ADDR orig_addr, addr, offset;
 945       int osect_idx;
 946       int seg;
 947
 948       osect_idx = osect - symfile_objfile->sections;
 949
 950       /* Current address of section.  */
 951       addr = obj_section_addr (osect);
 952       /* Offset from where this section started.  */
 953       offset = ANOFFSET (symfile_objfile->section_offsets, osect_idx);
 954       /* Original address prior to any past relocations.  */
 955       orig_addr = addr - offset;
 956
 957       for (seg = 0; seg < ldm->nsegs; seg++)
 958         {
 959           if (ldm->segs[seg].p_vaddr <= orig_addr
 960               && orig_addr < ldm->segs[seg].p_vaddr + ldm->segs[seg].p_memsz)
 961             {
 962               new_offsets->offsets[osect_idx]
 963                 = ldm->segs[seg].addr - ldm->segs[seg].p_vaddr;
 964
 965               if (new_offsets->offsets[osect_idx] != offset)
 966                 changed = 1;
 967               break;
 968             }
 969         }
 970     }
 971
 972   if (changed)
 973     objfile_relocate (symfile_objfile, new_offsets);
 974
 975   do_cleanups (old_chain);
 976
 977   /* Now that symfile_objfile has been relocated, we can compute the
 978      GOT value and stash it away.  */
 979 }
 980
 981 /* When gdb starts up the inferior, it nurses it along (through the
 982    shell) until it is ready to execute it's first instruction.  At this
 983    point, this function gets called via solib_create_inferior_hook.
 984
 985    For the DSBT shared library, the main executable needs to be relocated.
 986    The shared library breakpoints also need to be enabled.  */
 987
 988 static void
 989 dsbt_solib_create_inferior_hook (int from_tty)
 990 {
 991   /* Relocate main executable.  */
 992   dsbt_relocate_main_executable ();
 993
 994   /* Enable shared library breakpoints.  */
 995   if (!enable_break ())
 996     {
 997       warning (_("shared library handler failed to enable breakpoint"));
 998       return;
 999     }
1000 }
1001
1002 static void
1003 dsbt_clear_solib (void)
1004 {
1005   struct dsbt_info *info = get_dsbt_info ();
1006
1007   info->lm_base_cache = 0;
1008   info->main_lm_addr = 0;
1009   if (info->main_executable_lm_info != 0)
1010     {
1011       xfree (info->main_executable_lm_info->map);
1012       xfree (info->main_executable_lm_info);
1013       info->main_executable_lm_info = 0;
1014     }
1015 }
1016
1017 static void
1018 dsbt_free_so (struct so_list *so)
1019 {
1020   xfree (so->lm_info->map);
1021   xfree (so->lm_info);
1022 }
1023
1024 static void
1025 dsbt_relocate_section_addresses (struct so_list *so,
1026                                  struct target_section *sec)
1027 {
1028   int seg;
1029   struct int_elf32_dsbt_loadmap *map;
1030
1031   map = so->lm_info->map;
1032
1033   for (seg = 0; seg < map->nsegs; seg++)
1034     {
1035       if (map->segs[seg].p_vaddr <= sec->addr
1036           && sec->addr < map->segs[seg].p_vaddr + map->segs[seg].p_memsz)
1037         {
1038           CORE_ADDR displ = map->segs[seg].addr - map->segs[seg].p_vaddr;
1039
1040           sec->addr += displ;
1041           sec->endaddr += displ;
1042           break;
1043         }
1044     }
1045 }
1046 static void
1047 show_dsbt_debug (struct ui_file *file, int from_tty,
1048                  struct cmd_list_element *c, const char *value)
1049 {
1050   fprintf_filtered (file, _("solib-dsbt debugging is %s.\n"), value);
1051 }
1052
1053 struct target_so_ops dsbt_so_ops;
1054
1055 /* Provide a prototype to silence -Wmissing-prototypes.  */
1056 extern initialize_file_ftype _initialize_dsbt_solib;
1057
1058 void
1059 _initialize_dsbt_solib (void)
1060 {
1061   solib_dsbt_pspace_data
1062     = register_program_space_data_with_cleanup (NULL, dsbt_pspace_data_cleanup);
1063
1064   dsbt_so_ops.relocate_section_addresses = dsbt_relocate_section_addresses;
1065   dsbt_so_ops.free_so = dsbt_free_so;
1066   dsbt_so_ops.clear_solib = dsbt_clear_solib;
1067   dsbt_so_ops.solib_create_inferior_hook = dsbt_solib_create_inferior_hook;
1068   dsbt_so_ops.current_sos = dsbt_current_sos;
1069   dsbt_so_ops.open_symbol_file_object = open_symbol_file_object;
1070   dsbt_so_ops.in_dynsym_resolve_code = dsbt_in_dynsym_resolve_code;
1071   dsbt_so_ops.bfd_open = solib_bfd_open;
1072
1073   /* Debug this file's internals.  */
1074   add_setshow_zuinteger_cmd ("solib-dsbt", class_maintenance,
1075                              &solib_dsbt_debug, _("\
1076 Set internal debugging of shared library code for DSBT ELF."), _("\
1077 Show internal debugging of shared library code for DSBT ELF."), _("\
1078 When non-zero, DSBT solib specific internal debugging is enabled."),
1079                              NULL,
1080                              show_dsbt_debug,
1081                              &setdebuglist, &showdebuglist);
1082 }