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   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 797   asection *interp_sect;
 798   struct dsbt_info *info;
 799
 800   if (exec_bfd == NULL)
 801     return 0;
 802
 803   if (!target_has_execution)
 804     return 0;
 805
 806   info = get_dsbt_info ();
 807
 808   info->interp_text_sect_low = 0;
 809   info->interp_text_sect_high = 0;
 810   info->interp_plt_sect_low = 0;
 811   info->interp_plt_sect_high = 0;
 812
 813   /* Find the .interp section; if not found, warn the user and drop
 814      into the old breakpoint at symbol code.  */
 815   interp_sect = bfd_get_section_by_name (exec_bfd, ".interp");
 816   if (interp_sect)
 817     {
 818       unsigned int interp_sect_size;
 819       char *buf;
 820       bfd *tmp_bfd = NULL;
 821       CORE_ADDR addr;
 822       gdb_byte addr_buf[TIC6X_PTR_SIZE];
 823       struct int_elf32_dsbt_loadmap *ldm;
 824       int ret;
 825
 826       /* Read the contents of the .interp section into a local buffer;
 827          the contents specify the dynamic linker this program uses.  */
 828       interp_sect_size = bfd_section_size (exec_bfd, interp_sect);
 829       buf = (char *) alloca (interp_sect_size);
 830       bfd_get_section_contents (exec_bfd, interp_sect,
 831                                 buf, 0, interp_sect_size);
 832
 833       /* Now we need to figure out where the dynamic linker was
 834          loaded so that we can load its symbols and place a breakpoint
 835          in the dynamic linker itself.  */
 836
 837       TRY
 838         {
 839           tmp_bfd = solib_bfd_open (buf);
 840         }
 841       CATCH (ex, RETURN_MASK_ALL)
 842         {
 843         }
 844       END_CATCH
 845
 846       if (tmp_bfd == NULL)
 847         {
 848           enable_break_failure_warning ();
 849           return 0;
 850         }
 851
 852       dsbt_get_initial_loadmaps ();
 853       ldm = info->interp_loadmap;
 854
 855       /* Record the relocated start and end address of the dynamic linker
 856          text and plt section for dsbt_in_dynsym_resolve_code.  */
 857       interp_sect = bfd_get_section_by_name (tmp_bfd, ".text");
 858       if (interp_sect)
 859         {
 860           info->interp_text_sect_low
 861             = bfd_section_vma (tmp_bfd, interp_sect);
 862           info->interp_text_sect_low
 863             += displacement_from_map (ldm, info->interp_text_sect_low);
 864           info->interp_text_sect_high
 865             = info->interp_text_sect_low
 866             + bfd_section_size (tmp_bfd, interp_sect);
 867         }
 868       interp_sect = bfd_get_section_by_name (tmp_bfd, ".plt");
 869       if (interp_sect)
 870         {
 871           info->interp_plt_sect_low =
 872             bfd_section_vma (tmp_bfd, interp_sect);
 873           info->interp_plt_sect_low
 874             += displacement_from_map (ldm, info->interp_plt_sect_low);
 875           info->interp_plt_sect_high =
 876             info->interp_plt_sect_low + bfd_section_size (tmp_bfd, interp_sect);
 877         }
 878
 879       addr = gdb_bfd_lookup_symbol (tmp_bfd, cmp_name, "_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 temporary bfd.  */
 907       gdb_bfd_unref (tmp_bfd);
 908
 909       /* We're also done with the loadmap.  */
 910       xfree (ldm);
 911
 912       return ret;
 913     }
 914
 915   /* Tell the user we couldn't set a dynamic linker breakpoint.  */
 916   enable_break_failure_warning ();
 917
 918   /* Failure return.  */
 919   return 0;
 920 }
 921
 922 /* Once the symbols from a shared object have been loaded in the usual
 923    way, we are called to do any system specific symbol handling that
 924    is needed.  */
 925
 926 static void
 927 dsbt_special_symbol_handling (void)
 928 {
 929 }
 930
 931 static void
 932 dsbt_relocate_main_executable (void)
 933 {
 934   struct int_elf32_dsbt_loadmap *ldm;
 935   struct cleanup *old_chain;
 936   struct section_offsets *new_offsets;
 937   int changed;
 938   struct obj_section *osect;
 939   struct dsbt_info *info = get_dsbt_info ();
 940
 941   dsbt_get_initial_loadmaps ();
 942   ldm = info->exec_loadmap;
 943
 944   xfree (info->main_executable_lm_info);
 945   info->main_executable_lm_info = XCNEW (struct lm_info);
 946   info->main_executable_lm_info->map = ldm;
 947
 948   new_offsets = XCNEWVEC (struct section_offsets,
 949                           symfile_objfile->num_sections);
 950   old_chain = make_cleanup (xfree, new_offsets);
 951   changed = 0;
 952
 953   ALL_OBJFILE_OSECTIONS (symfile_objfile, osect)
 954     {
 955       CORE_ADDR orig_addr, addr, offset;
 956       int osect_idx;
 957       int seg;
 958
 959       osect_idx = osect - symfile_objfile->sections;
 960
 961       /* Current address of section.  */
 962       addr = obj_section_addr (osect);
 963       /* Offset from where this section started.  */
 964       offset = ANOFFSET (symfile_objfile->section_offsets, osect_idx);
 965       /* Original address prior to any past relocations.  */
 966       orig_addr = addr - offset;
 967
 968       for (seg = 0; seg < ldm->nsegs; seg++)
 969         {
 970           if (ldm->segs[seg].p_vaddr <= orig_addr
 971               && orig_addr < ldm->segs[seg].p_vaddr + ldm->segs[seg].p_memsz)
 972             {
 973               new_offsets->offsets[osect_idx]
 974                 = ldm->segs[seg].addr - ldm->segs[seg].p_vaddr;
 975
 976               if (new_offsets->offsets[osect_idx] != offset)
 977                 changed = 1;
 978               break;
 979             }
 980         }
 981     }
 982
 983   if (changed)
 984     objfile_relocate (symfile_objfile, new_offsets);
 985
 986   do_cleanups (old_chain);
 987
 988   /* Now that symfile_objfile has been relocated, we can compute the
 989      GOT value and stash it away.  */
 990 }
 991
 992 /* When gdb starts up the inferior, it nurses it along (through the
 993    shell) until it is ready to execute it's first instruction.  At this
 994    point, this function gets called via solib_create_inferior_hook.
 995
 996    For the DSBT shared library, the main executable needs to be relocated.
 997    The shared library breakpoints also need to be enabled.  */
 998
 999 static void
1000 dsbt_solib_create_inferior_hook (int from_tty)
1001 {
1002   /* Relocate main executable.  */
1003   dsbt_relocate_main_executable ();
1004
1005   /* Enable shared library breakpoints.  */
1006   if (!enable_break ())
1007     {
1008       warning (_("shared library handler failed to enable breakpoint"));
1009       return;
1010     }
1011 }
1012
1013 static void
1014 dsbt_clear_solib (void)
1015 {
1016   struct dsbt_info *info = get_dsbt_info ();
1017
1018   info->lm_base_cache = 0;
1019   info->main_lm_addr = 0;
1020   if (info->main_executable_lm_info != 0)
1021     {
1022       xfree (info->main_executable_lm_info->map);
1023       xfree (info->main_executable_lm_info);
1024       info->main_executable_lm_info = 0;
1025     }
1026 }
1027
1028 static void
1029 dsbt_free_so (struct so_list *so)
1030 {
1031   xfree (so->lm_info->map);
1032   xfree (so->lm_info);
1033 }
1034
1035 static void
1036 dsbt_relocate_section_addresses (struct so_list *so,
1037                                  struct target_section *sec)
1038 {
1039   int seg;
1040   struct int_elf32_dsbt_loadmap *map;
1041
1042   map = so->lm_info->map;
1043
1044   for (seg = 0; seg < map->nsegs; seg++)
1045     {
1046       if (map->segs[seg].p_vaddr <= sec->addr
1047           && sec->addr < map->segs[seg].p_vaddr + map->segs[seg].p_memsz)
1048         {
1049           CORE_ADDR displ = map->segs[seg].addr - map->segs[seg].p_vaddr;
1050
1051           sec->addr += displ;
1052           sec->endaddr += displ;
1053           break;
1054         }
1055     }
1056 }
1057 static void
1058 show_dsbt_debug (struct ui_file *file, int from_tty,
1059                  struct cmd_list_element *c, const char *value)
1060 {
1061   fprintf_filtered (file, _("solib-dsbt debugging is %s.\n"), value);
1062 }
1063
1064 struct target_so_ops dsbt_so_ops;
1065
1066 /* Provide a prototype to silence -Wmissing-prototypes.  */
1067 extern initialize_file_ftype _initialize_dsbt_solib;
1068
1069 void
1070 _initialize_dsbt_solib (void)
1071 {
1072   solib_dsbt_pspace_data
1073     = register_program_space_data_with_cleanup (NULL, dsbt_pspace_data_cleanup);
1074
1075   dsbt_so_ops.relocate_section_addresses = dsbt_relocate_section_addresses;
1076   dsbt_so_ops.free_so = dsbt_free_so;
1077   dsbt_so_ops.clear_solib = dsbt_clear_solib;
1078   dsbt_so_ops.solib_create_inferior_hook = dsbt_solib_create_inferior_hook;
1079   dsbt_so_ops.special_symbol_handling = dsbt_special_symbol_handling;
1080   dsbt_so_ops.current_sos = dsbt_current_sos;
1081   dsbt_so_ops.open_symbol_file_object = open_symbol_file_object;
1082   dsbt_so_ops.in_dynsym_resolve_code = dsbt_in_dynsym_resolve_code;
1083   dsbt_so_ops.bfd_open = solib_bfd_open;
1084
1085   /* Debug this file's internals.  */
1086   add_setshow_zuinteger_cmd ("solib-dsbt", class_maintenance,
1087                              &solib_dsbt_debug, _("\
1088 Set internal debugging of shared library code for DSBT ELF."), _("\
1089 Show internal debugging of shared library code for DSBT ELF."), _("\
1090 When non-zero, DSBT solib specific internal debugging is enabled."),
1091                              NULL,
1092                              show_dsbt_debug,
1093                              &setdebuglist, &showdebuglist);
1094 }