gdb/solib-dsbt.c

   1 /* Handle TIC6X (DSBT) shared libraries for GDB, the GNU Debugger.
   2    Copyright (C) 2010-2018 Free Software Foundation, Inc.
   3
   4    This file is part of GDB.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  18
  19
  20 #include "defs.h"
  21 #include "inferior.h"
  22 #include "gdbcore.h"
  23 #include "solib.h"
  24 #include "solist.h"
  25 #include "objfiles.h"
  26 #include "symtab.h"
  27 #include "language.h"
  28 #include "command.h"
  29 #include "gdbcmd.h"
  30 #include "elf-bfd.h"
  31 #include "gdb_bfd.h"
  32
  33 #define GOT_MODULE_OFFSET 4
  34
  35 /* Flag which indicates whether internal debug messages should be printed.  */
  36 static unsigned int solib_dsbt_debug = 0;
  37
  38 /* TIC6X pointers are four bytes wide.  */
  39 enum { TIC6X_PTR_SIZE = 4 };
  40
  41 /* Representation of loadmap and related structs for the TIC6X DSBT.  */
  42
  43 /* External versions; the size and alignment of the fields should be
  44    the same as those on the target.  When loaded, the placement of
  45    the bits in each field will be the same as on the target.  */
  46 typedef gdb_byte ext_Elf32_Half[2];
  47 typedef gdb_byte ext_Elf32_Addr[4];
  48 typedef gdb_byte ext_Elf32_Word[4];
  49
  50 struct ext_elf32_dsbt_loadseg
  51 {
  52   /* Core address to which the segment is mapped.  */
  53   ext_Elf32_Addr addr;
  54   /* VMA recorded in the program header.  */
  55   ext_Elf32_Addr p_vaddr;
  56   /* Size of this segment in memory.  */
  57   ext_Elf32_Word p_memsz;
  58 };
  59
  60 struct ext_elf32_dsbt_loadmap {
  61   /* Protocol version number, must be zero.  */
  62   ext_Elf32_Word version;
  63   /* A pointer to the DSBT table; the DSBT size and the index of this
  64      module.  */
  65   ext_Elf32_Word dsbt_table_ptr;
  66   ext_Elf32_Word dsbt_size;
  67   ext_Elf32_Word dsbt_index;
  68   /* Number of segments in this map.  */
  69   ext_Elf32_Word nsegs;
  70   /* The actual memory map.  */
  71   struct ext_elf32_dsbt_loadseg segs[1 /* nsegs, actually */];
  72 };
  73
  74 /* Internal versions; the types are GDB types and the data in each
  75    of the fields is (or will be) decoded from the external struct
  76    for ease of consumption.  */
  77 struct int_elf32_dsbt_loadseg
  78 {
  79   /* Core address to which the segment is mapped.  */
  80   CORE_ADDR addr;
  81   /* VMA recorded in the program header.  */
  82   CORE_ADDR p_vaddr;
  83   /* Size of this segment in memory.  */
  84   long p_memsz;
  85 };
  86
  87 struct int_elf32_dsbt_loadmap
  88 {
  89   /* Protocol version number, must be zero.  */
  90   int version;
  91   CORE_ADDR dsbt_table_ptr;
  92   /* A pointer to the DSBT table; the DSBT size and the index of this
  93      module.  */
  94   int dsbt_size, dsbt_index;
  95   /* Number of segments in this map.  */
  96   int nsegs;
  97   /* The actual memory map.  */
  98   struct int_elf32_dsbt_loadseg segs[1 /* nsegs, actually */];
  99 };
 100
 101 /* External link_map and elf32_dsbt_loadaddr struct definitions.  */
 102
 103 typedef gdb_byte ext_ptr[4];
 104
 105 struct ext_elf32_dsbt_loadaddr
 106 {
 107   ext_ptr map;                  /* struct elf32_dsbt_loadmap *map; */
 108 };
 109
 110 struct ext_link_map
 111 {
 112   struct ext_elf32_dsbt_loadaddr l_addr;
 113
 114   /* Absolute file name object was found in.  */
 115   ext_ptr l_name;               /* char *l_name; */
 116
 117   /* Dynamic section of the shared object.  */
 118   ext_ptr l_ld;                 /* ElfW(Dyn) *l_ld; */
 119
 120   /* Chain of loaded objects.  */
 121   ext_ptr l_next, l_prev;       /* struct link_map *l_next, *l_prev; */
 122 };
 123
 124 /* Link map info to include in an allocated so_list entry */
 125
 126 struct lm_info_dsbt : public lm_info_base
 127 {
 128   ~lm_info_dsbt ()
 129   {
 130     xfree (this->map);
 131   }
 132
 133   /* The loadmap, digested into an easier to use form.  */
 134   int_elf32_dsbt_loadmap *map = NULL;
 135 };
 136
 137 /* Per pspace dsbt specific data.  */
 138
 139 struct dsbt_info
 140 {
 141   /* The load map, got value, etc. are not available from the chain
 142      of loaded shared objects.  ``main_executable_lm_info'' provides
 143      a way to get at this information so that it doesn't need to be
 144      frequently recomputed.  Initialized by dsbt_relocate_main_executable.  */
 145   struct lm_info_dsbt *main_executable_lm_info;
 146
 147   /* Load maps for the main executable and the interpreter.  These are obtained
 148      from ptrace.  They are the starting point for getting into the program,
 149      and are required to find the solib list with the individual load maps for
 150      each module.  */
 151   struct int_elf32_dsbt_loadmap *exec_loadmap;
 152   struct int_elf32_dsbt_loadmap *interp_loadmap;
 153
 154   /* Cached value for lm_base, below.  */
 155   CORE_ADDR lm_base_cache;
 156
 157   /* Link map address for main module.  */
 158   CORE_ADDR main_lm_addr;
 159
 160   CORE_ADDR interp_text_sect_low;
 161   CORE_ADDR interp_text_sect_high;
 162   CORE_ADDR interp_plt_sect_low;
 163   CORE_ADDR interp_plt_sect_high;
 164 };
 165
 166 /* Per-program-space data key.  */
 167 static const struct program_space_data *solib_dsbt_pspace_data;
 168
 169 static void
 170 dsbt_pspace_data_cleanup (struct program_space *pspace, void *arg)
 171 {
 172   xfree (arg);
 173 }
 174
 175 /* Get the current dsbt data.  If none is found yet, add it now.  This
 176    function always returns a valid object.  */
 177
 178 static struct dsbt_info *
 179 get_dsbt_info (void)
 180 {
 181   struct dsbt_info *info;
 182
 183   info = (struct dsbt_info *) program_space_data (current_program_space,
 184                                                   solib_dsbt_pspace_data);
 185   if (info != NULL)
 186     return info;
 187
 188   info = XCNEW (struct dsbt_info);
 189   set_program_space_data (current_program_space, solib_dsbt_pspace_data, info);
 190
 191   info->lm_base_cache = 0;
 192   info->main_lm_addr = 0;
 193
 194   return info;
 195 }
 196
 197
 198 static void
 199 dsbt_print_loadmap (struct int_elf32_dsbt_loadmap *map)
 200 {
 201   int i;
 202
 203   if (map == NULL)
 204     printf_filtered ("(null)\n");
 205   else if (map->version != 0)
 206     printf_filtered (_("Unsupported map version: %d\n"), map->version);
 207   else
 208     {
 209       printf_filtered ("version %d\n", map->version);
 210
 211       for (i = 0; i < map->nsegs; i++)
 212         printf_filtered ("%s:%s -> %s:%s\n",
 213                          print_core_address (target_gdbarch (),
 214                                              map->segs[i].p_vaddr),
 215                          print_core_address (target_gdbarch (),
 216                                              map->segs[i].p_vaddr
 217                                              + map->segs[i].p_memsz),
 218                          print_core_address (target_gdbarch (), map->segs[i].addr),
 219                          print_core_address (target_gdbarch (), map->segs[i].addr
 220                                              + map->segs[i].p_memsz));
 221     }
 222 }
 223
 224 /* Decode int_elf32_dsbt_loadmap from BUF.  */
 225
 226 static struct int_elf32_dsbt_loadmap *
 227 decode_loadmap (gdb_byte *buf)
 228 {
 229   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 230   struct ext_elf32_dsbt_loadmap *ext_ldmbuf;
 231   struct int_elf32_dsbt_loadmap *int_ldmbuf;
 232
 233   int version, seg, nsegs;
 234   int int_ldmbuf_size;
 235
 236   ext_ldmbuf = (struct ext_elf32_dsbt_loadmap *) buf;
 237
 238   /* Extract the version.  */
 239   version = extract_unsigned_integer (ext_ldmbuf->version,
 240                                       sizeof ext_ldmbuf->version,
 241                                       byte_order);
 242   if (version != 0)
 243     {
 244       /* We only handle version 0.  */
 245       return NULL;
 246     }
 247
 248   /* Extract the number of segments.  */
 249   nsegs = extract_unsigned_integer (ext_ldmbuf->nsegs,
 250                                     sizeof ext_ldmbuf->nsegs,
 251                                     byte_order);
 252
 253   if (nsegs <= 0)
 254     return NULL;
 255
 256   /* Allocate space into which to put information extract from the
 257      external loadsegs.  I.e, allocate the internal loadsegs.  */
 258   int_ldmbuf_size = (sizeof (struct int_elf32_dsbt_loadmap)
 259                      + (nsegs - 1) * sizeof (struct int_elf32_dsbt_loadseg));
 260   int_ldmbuf = (struct int_elf32_dsbt_loadmap *) xmalloc (int_ldmbuf_size);
 261
 262   /* Place extracted information in internal structs.  */
 263   int_ldmbuf->version = version;
 264   int_ldmbuf->nsegs = nsegs;
 265   for (seg = 0; seg < nsegs; seg++)
 266     {
 267       int_ldmbuf->segs[seg].addr
 268         = extract_unsigned_integer (ext_ldmbuf->segs[seg].addr,
 269                                     sizeof (ext_ldmbuf->segs[seg].addr),
 270                                     byte_order);
 271       int_ldmbuf->segs[seg].p_vaddr
 272         = extract_unsigned_integer (ext_ldmbuf->segs[seg].p_vaddr,
 273                                     sizeof (ext_ldmbuf->segs[seg].p_vaddr),
 274                                     byte_order);
 275       int_ldmbuf->segs[seg].p_memsz
 276         = extract_unsigned_integer (ext_ldmbuf->segs[seg].p_memsz,
 277                                     sizeof (ext_ldmbuf->segs[seg].p_memsz),
 278                                     byte_order);
 279     }
 280
 281   xfree (ext_ldmbuf);
 282   return int_ldmbuf;
 283 }
 284
 285
 286 static struct dsbt_info *get_dsbt_info (void);
 287
 288 /* Interrogate the Linux kernel to find out where the program was loaded.
 289    There are two load maps; one for the executable and one for the
 290    interpreter (only in the case of a dynamically linked executable).  */
 291
 292 static void
 293 dsbt_get_initial_loadmaps (void)
 294 {
 295   gdb_byte *buf;
 296   struct dsbt_info *info = get_dsbt_info ();
 297
 298   if (0 >= target_read_alloc (&current_target, TARGET_OBJECT_FDPIC,
 299                               "exec", &buf))
 300     {
 301       info->exec_loadmap = NULL;
 302       error (_("Error reading DSBT exec loadmap"));
 303     }
 304   info->exec_loadmap = decode_loadmap (buf);
 305   if (solib_dsbt_debug)
 306     dsbt_print_loadmap (info->exec_loadmap);
 307
 308   if (0 >= target_read_alloc (&current_target, TARGET_OBJECT_FDPIC,
 309                               "interp", &buf))
 310     {
 311       info->interp_loadmap = NULL;
 312       error (_("Error reading DSBT interp loadmap"));
 313     }
 314   info->interp_loadmap = decode_loadmap (buf);
 315   if (solib_dsbt_debug)
 316     dsbt_print_loadmap (info->interp_loadmap);
 317 }
 318
 319 /* Given address LDMADDR, fetch and decode the loadmap at that address.
 320    Return NULL if there is a problem reading the target memory or if
 321    there doesn't appear to be a loadmap at the given address.  The
 322    allocated space (representing the loadmap) returned by this
 323    function may be freed via a single call to xfree.  */
 324
 325 static struct int_elf32_dsbt_loadmap *
 326 fetch_loadmap (CORE_ADDR ldmaddr)
 327 {
 328   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 329   struct ext_elf32_dsbt_loadmap ext_ldmbuf_partial;
 330   struct ext_elf32_dsbt_loadmap *ext_ldmbuf;
 331   struct int_elf32_dsbt_loadmap *int_ldmbuf;
 332   int ext_ldmbuf_size, int_ldmbuf_size;
 333   int version, seg, nsegs;
 334
 335   /* Fetch initial portion of the loadmap.  */
 336   if (target_read_memory (ldmaddr, (gdb_byte *) &ext_ldmbuf_partial,
 337                           sizeof ext_ldmbuf_partial))
 338     {
 339       /* Problem reading the target's memory.  */
 340       return NULL;
 341     }
 342
 343   /* Extract the version.  */
 344   version = extract_unsigned_integer (ext_ldmbuf_partial.version,
 345                                       sizeof ext_ldmbuf_partial.version,
 346                                       byte_order);
 347   if (version != 0)
 348     {
 349       /* We only handle version 0.  */
 350       return NULL;
 351     }
 352
 353   /* Extract the number of segments.  */
 354   nsegs = extract_unsigned_integer (ext_ldmbuf_partial.nsegs,
 355                                     sizeof ext_ldmbuf_partial.nsegs,
 356                                     byte_order);
 357
 358   if (nsegs <= 0)
 359     return NULL;
 360
 361   /* Allocate space for the complete (external) loadmap.  */
 362   ext_ldmbuf_size = sizeof (struct ext_elf32_dsbt_loadmap)
 363     + (nsegs - 1) * sizeof (struct ext_elf32_dsbt_loadseg);
 364   ext_ldmbuf = (struct ext_elf32_dsbt_loadmap *) xmalloc (ext_ldmbuf_size);
 365
 366   /* Copy over the portion of the loadmap that's already been read.  */
 367   memcpy (ext_ldmbuf, &ext_ldmbuf_partial, sizeof ext_ldmbuf_partial);
 368
 369   /* Read the rest of the loadmap from the target.  */
 370   if (target_read_memory (ldmaddr + sizeof ext_ldmbuf_partial,
 371                           (gdb_byte *) ext_ldmbuf + sizeof ext_ldmbuf_partial,
 372                           ext_ldmbuf_size - sizeof ext_ldmbuf_partial))
 373     {
 374       /* Couldn't read rest of the loadmap.  */
 375       xfree (ext_ldmbuf);
 376       return NULL;
 377     }
 378
 379   /* Allocate space into which to put information extract from the
 380      external loadsegs.  I.e, allocate the internal loadsegs.  */
 381   int_ldmbuf_size = sizeof (struct int_elf32_dsbt_loadmap)
 382     + (nsegs - 1) * sizeof (struct int_elf32_dsbt_loadseg);
 383   int_ldmbuf = (struct int_elf32_dsbt_loadmap *) xmalloc (int_ldmbuf_size);
 384
 385   /* Place extracted information in internal structs.  */
 386   int_ldmbuf->version = version;
 387   int_ldmbuf->nsegs = nsegs;
 388   for (seg = 0; seg < nsegs; seg++)
 389     {
 390       int_ldmbuf->segs[seg].addr
 391         = extract_unsigned_integer (ext_ldmbuf->segs[seg].addr,
 392                                     sizeof (ext_ldmbuf->segs[seg].addr),
 393                                     byte_order);
 394       int_ldmbuf->segs[seg].p_vaddr
 395         = extract_unsigned_integer (ext_ldmbuf->segs[seg].p_vaddr,
 396                                     sizeof (ext_ldmbuf->segs[seg].p_vaddr),
 397                                     byte_order);
 398       int_ldmbuf->segs[seg].p_memsz
 399         = extract_unsigned_integer (ext_ldmbuf->segs[seg].p_memsz,
 400                                     sizeof (ext_ldmbuf->segs[seg].p_memsz),
 401                                     byte_order);
 402     }
 403
 404   xfree (ext_ldmbuf);
 405   return int_ldmbuf;
 406 }
 407
 408 static void dsbt_relocate_main_executable (void);
 409 static int enable_break (void);
 410
 411 /* Scan for DYNTAG in .dynamic section of ABFD. If DYNTAG is found 1 is
 412    returned and the corresponding PTR is set.  */
 413
 414 static int
 415 scan_dyntag (int dyntag, bfd *abfd, CORE_ADDR *ptr)
 416 {
 417   int arch_size, step, sect_size;
 418   long dyn_tag;
 419   CORE_ADDR dyn_ptr, dyn_addr;
 420   gdb_byte *bufend, *bufstart, *buf;
 421   Elf32_External_Dyn *x_dynp_32;
 422   Elf64_External_Dyn *x_dynp_64;
 423   struct bfd_section *sect;
 424   struct target_section *target_section;
 425
 426   if (abfd == NULL)
 427     return 0;
 428
 429   if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
 430     return 0;
 431
 432   arch_size = bfd_get_arch_size (abfd);
 433   if (arch_size == -1)
 434     return 0;
 435
 436   /* Find the start address of the .dynamic section.  */
 437   sect = bfd_get_section_by_name (abfd, ".dynamic");
 438   if (sect == NULL)
 439     return 0;
 440
 441   for (target_section = current_target_sections->sections;
 442        target_section < current_target_sections->sections_end;
 443        target_section++)
 444     if (sect == target_section->the_bfd_section)
 445       break;
 446   if (target_section < current_target_sections->sections_end)
 447     dyn_addr = target_section->addr;
 448   else
 449     {
 450       /* ABFD may come from OBJFILE acting only as a symbol file without being
 451          loaded into the target (see add_symbol_file_command).  This case is
 452          such fallback to the file VMA address without the possibility of
 453          having the section relocated to its actual in-memory address.  */
 454
 455       dyn_addr = bfd_section_vma (abfd, sect);
 456     }
 457
 458   /* Read in .dynamic from the BFD.  We will get the actual value
 459      from memory later.  */
 460   sect_size = bfd_section_size (abfd, sect);
 461   buf = bufstart = (gdb_byte *) alloca (sect_size);
 462   if (!bfd_get_section_contents (abfd, sect,
 463                                  buf, 0, sect_size))
 464     return 0;
 465
 466   /* Iterate over BUF and scan for DYNTAG.  If found, set PTR and return.  */
 467   step = (arch_size == 32) ? sizeof (Elf32_External_Dyn)
 468                            : sizeof (Elf64_External_Dyn);
 469   for (bufend = buf + sect_size;
 470        buf < bufend;
 471        buf += step)
 472   {
 473     if (arch_size == 32)
 474       {
 475         x_dynp_32 = (Elf32_External_Dyn *) buf;
 476         dyn_tag = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp_32->d_tag);
 477         dyn_ptr = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp_32->d_un.d_ptr);
 478       }
 479     else
 480       {
 481         x_dynp_64 = (Elf64_External_Dyn *) buf;
 482         dyn_tag = bfd_h_get_64 (abfd, (bfd_byte *) x_dynp_64->d_tag);
 483         dyn_ptr = bfd_h_get_64 (abfd, (bfd_byte *) x_dynp_64->d_un.d_ptr);
 484       }
 485      if (dyn_tag == DT_NULL)
 486        return 0;
 487      if (dyn_tag == dyntag)
 488        {
 489          /* If requested, try to read the runtime value of this .dynamic
 490             entry.  */
 491          if (ptr)
 492            {
 493              struct type *ptr_type;
 494              gdb_byte ptr_buf[8];
 495              CORE_ADDR ptr_addr;
 496
 497              ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
 498              ptr_addr = dyn_addr + (buf - bufstart) + arch_size / 8;
 499              if (target_read_memory (ptr_addr, ptr_buf, arch_size / 8) == 0)
 500                dyn_ptr = extract_typed_address (ptr_buf, ptr_type);
 501              *ptr = dyn_ptr;
 502            }
 503          return 1;
 504        }
 505   }
 506
 507   return 0;
 508 }
 509
 510 /* See solist.h. */
 511
 512 static int
 513 open_symbol_file_object (int from_tty)
 514 {
 515   /* Unimplemented.  */
 516   return 0;
 517 }
 518
 519 /* Given a loadmap and an address, return the displacement needed
 520    to relocate the address.  */
 521
 522 static CORE_ADDR
 523 displacement_from_map (struct int_elf32_dsbt_loadmap *map,
 524                        CORE_ADDR addr)
 525 {
 526   int seg;
 527
 528   for (seg = 0; seg < map->nsegs; seg++)
 529     if (map->segs[seg].p_vaddr <= addr
 530         && addr < map->segs[seg].p_vaddr + map->segs[seg].p_memsz)
 531       return map->segs[seg].addr - map->segs[seg].p_vaddr;
 532
 533   return 0;
 534 }
 535
 536 /* Return the address from which the link map chain may be found.  On
 537    DSBT, a pointer to the start of the link map will be located at the
 538    word found at base of GOT + GOT_MODULE_OFFSET.
 539
 540    The base of GOT may be found in a number of ways.  Assuming that the
 541    main executable has already been relocated,
 542    1 The easiest way to find this value is to look up the address of
 543    _GLOBAL_OFFSET_TABLE_.
 544    2 The other way is to look for tag DT_PLTGOT, which contains the virtual
 545    address of Global Offset Table.  .*/
 546
 547 static CORE_ADDR
 548 lm_base (void)
 549 {
 550   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 551   struct bound_minimal_symbol got_sym;
 552   CORE_ADDR addr;
 553   gdb_byte buf[TIC6X_PTR_SIZE];
 554   struct dsbt_info *info = get_dsbt_info ();
 555
 556   /* One of our assumptions is that the main executable has been relocated.
 557      Bail out if this has not happened.  (Note that post_create_inferior
 558      in infcmd.c will call solib_add prior to solib_create_inferior_hook.
 559      If we allow this to happen, lm_base_cache will be initialized with
 560      a bogus value.  */
 561   if (info->main_executable_lm_info == 0)
 562     return 0;
 563
 564   /* If we already have a cached value, return it.  */
 565   if (info->lm_base_cache)
 566     return info->lm_base_cache;
 567
 568   got_sym = lookup_minimal_symbol ("_GLOBAL_OFFSET_TABLE_", NULL,
 569                                    symfile_objfile);
 570
 571   if (got_sym.minsym != 0)
 572     {
 573       addr = BMSYMBOL_VALUE_ADDRESS (got_sym);
 574       if (solib_dsbt_debug)
 575         fprintf_unfiltered (gdb_stdlog,
 576                             "lm_base: get addr %x by _GLOBAL_OFFSET_TABLE_.\n",
 577                             (unsigned int) addr);
 578     }
 579   else if (scan_dyntag (DT_PLTGOT, exec_bfd, &addr))
 580     {
 581       struct int_elf32_dsbt_loadmap *ldm;
 582
 583       dsbt_get_initial_loadmaps ();
 584       ldm = info->exec_loadmap;
 585       addr += displacement_from_map (ldm, addr);
 586       if (solib_dsbt_debug)
 587         fprintf_unfiltered (gdb_stdlog,
 588                             "lm_base: get addr %x by DT_PLTGOT.\n",
 589                             (unsigned int) addr);
 590     }
 591   else
 592     {
 593       if (solib_dsbt_debug)
 594         fprintf_unfiltered (gdb_stdlog,
 595                             "lm_base: _GLOBAL_OFFSET_TABLE_ not found.\n");
 596       return 0;
 597     }
 598   addr += GOT_MODULE_OFFSET;
 599
 600   if (solib_dsbt_debug)
 601     fprintf_unfiltered (gdb_stdlog,
 602                         "lm_base: _GLOBAL_OFFSET_TABLE_ + %d = %s\n",
 603                         GOT_MODULE_OFFSET, hex_string_custom (addr, 8));
 604
 605   if (target_read_memory (addr, buf, sizeof buf) != 0)
 606     return 0;
 607   info->lm_base_cache = extract_unsigned_integer (buf, sizeof buf, byte_order);
 608
 609   if (solib_dsbt_debug)
 610     fprintf_unfiltered (gdb_stdlog,
 611                         "lm_base: lm_base_cache = %s\n",
 612                         hex_string_custom (info->lm_base_cache, 8));
 613
 614   return info->lm_base_cache;
 615 }
 616
 617
 618 /* Build a list of `struct so_list' objects describing the shared
 619    objects currently loaded in the inferior.  This list does not
 620    include an entry for the main executable file.
 621
 622    Note that we only gather information directly available from the
 623    inferior --- we don't examine any of the shared library files
 624    themselves.  The declaration of `struct so_list' says which fields
 625    we provide values for.  */
 626
 627 static struct so_list *
 628 dsbt_current_sos (void)
 629 {
 630   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 631   CORE_ADDR lm_addr;
 632   struct so_list *sos_head = NULL;
 633   struct so_list **sos_next_ptr = &sos_head;
 634   struct dsbt_info *info = get_dsbt_info ();
 635
 636   /* Make sure that the main executable has been relocated.  This is
 637      required in order to find the address of the global offset table,
 638      which in turn is used to find the link map info.  (See lm_base
 639      for details.)
 640
 641      Note that the relocation of the main executable is also performed
 642      by solib_create_inferior_hook, however, in the case of core
 643      files, this hook is called too late in order to be of benefit to
 644      solib_add.  solib_add eventually calls this function,
 645      dsbt_current_sos, and also precedes the call to
 646      solib_create_inferior_hook.   (See post_create_inferior in
 647      infcmd.c.)  */
 648   if (info->main_executable_lm_info == 0 && core_bfd != NULL)
 649     dsbt_relocate_main_executable ();
 650
 651   /* Locate the address of the first link map struct.  */
 652   lm_addr = lm_base ();
 653
 654   /* We have at least one link map entry.  Fetch the the lot of them,
 655      building the solist chain.  */
 656   while (lm_addr)
 657     {
 658       struct ext_link_map lm_buf;
 659       ext_Elf32_Word indexword;
 660       CORE_ADDR map_addr;
 661       int dsbt_index;
 662       int ret;
 663
 664       if (solib_dsbt_debug)
 665         fprintf_unfiltered (gdb_stdlog,
 666                             "current_sos: reading link_map entry at %s\n",
 667                             hex_string_custom (lm_addr, 8));
 668
 669       ret = target_read_memory (lm_addr, (gdb_byte *) &lm_buf, sizeof (lm_buf));
 670       if (ret)
 671         {
 672           warning (_("dsbt_current_sos: Unable to read link map entry."
 673                      "  Shared object chain may be incomplete."));
 674           break;
 675         }
 676
 677       /* Fetch the load map address.  */
 678       map_addr = extract_unsigned_integer (lm_buf.l_addr.map,
 679                                            sizeof lm_buf.l_addr.map,
 680                                            byte_order);
 681
 682       ret = target_read_memory (map_addr + 12, (gdb_byte *) &indexword,
 683                                 sizeof indexword);
 684       if (ret)
 685         {
 686           warning (_("dsbt_current_sos: Unable to read dsbt index."
 687                      "  Shared object chain may be incomplete."));
 688           break;
 689         }
 690       dsbt_index = extract_unsigned_integer (indexword, sizeof indexword,
 691                                              byte_order);
 692
 693       /* If the DSBT index is zero, then we're looking at the entry
 694          for the main executable.  By convention, we don't include
 695          this in the list of shared objects.  */
 696       if (dsbt_index != 0)
 697         {
 698           int errcode;
 699           gdb::unique_xmalloc_ptr<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.get ());
 731
 732               strncpy (sop->so_name, name_buf.get (), SO_NAME_MAX_PATH_SIZE - 1);
 733               sop->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
 734               strcpy (sop->so_original_name, sop->so_name);
 735             }
 736
 737           *sos_next_ptr = sop;
 738           sos_next_ptr = &sop->next;
 739         }
 740       else
 741         {
 742           info->main_lm_addr = lm_addr;
 743         }
 744
 745       lm_addr = extract_unsigned_integer (lm_buf.l_next,
 746                                           sizeof (lm_buf.l_next), byte_order);
 747     }
 748
 749   return sos_head;
 750 }
 751
 752 /* Return 1 if PC lies in the dynamic symbol resolution code of the
 753    run time loader.  */
 754
 755 static int
 756 dsbt_in_dynsym_resolve_code (CORE_ADDR pc)
 757 {
 758   struct dsbt_info *info = get_dsbt_info ();
 759
 760   return ((pc >= info->interp_text_sect_low && pc < info->interp_text_sect_high)
 761           || (pc >= info->interp_plt_sect_low && pc < info->interp_plt_sect_high)
 762           || in_plt_section (pc));
 763 }
 764
 765 /* Print a warning about being unable to set the dynamic linker
 766    breakpoint.  */
 767
 768 static void
 769 enable_break_failure_warning (void)
 770 {
 771   warning (_("Unable to find dynamic linker breakpoint function.\n"
 772              "GDB will be unable to debug shared library initializers\n"
 773              "and track explicitly loaded dynamic code."));
 774 }
 775
 776 /* Helper function for gdb_bfd_lookup_symbol.  */
 777
 778 static int
 779 cmp_name (const asymbol *sym, const void *data)
 780 {
 781   return (strcmp (sym->name, (const char *) data) == 0);
 782 }
 783
 784 /* The dynamic linkers has, as part of its debugger interface, support
 785    for arranging for the inferior to hit a breakpoint after mapping in
 786    the shared libraries.  This function enables that breakpoint.
 787
 788    On the TIC6X, using the shared library (DSBT), GDB can try to place
 789    a breakpoint on '_dl_debug_state' to monitor the shared library
 790    event.  */
 791
 792 static int
 793 enable_break (void)
 794 {
 795   asection *interp_sect;
 796   struct dsbt_info *info;
 797
 798   if (exec_bfd == NULL)
 799     return 0;
 800
 801   if (!target_has_execution)
 802     return 0;
 803
 804   info = get_dsbt_info ();
 805
 806   info->interp_text_sect_low = 0;
 807   info->interp_text_sect_high = 0;
 808   info->interp_plt_sect_low = 0;
 809   info->interp_plt_sect_high = 0;
 810
 811   /* Find the .interp section; if not found, warn the user and drop
 812      into the old breakpoint at symbol code.  */
 813   interp_sect = bfd_get_section_by_name (exec_bfd, ".interp");
 814   if (interp_sect)
 815     {
 816       unsigned int interp_sect_size;
 817       char *buf;
 818       CORE_ADDR addr;
 819       struct int_elf32_dsbt_loadmap *ldm;
 820       int ret;
 821
 822       /* Read the contents of the .interp section into a local buffer;
 823          the contents specify the dynamic linker this program uses.  */
 824       interp_sect_size = bfd_section_size (exec_bfd, interp_sect);
 825       buf = (char *) alloca (interp_sect_size);
 826       bfd_get_section_contents (exec_bfd, interp_sect,
 827                                 buf, 0, interp_sect_size);
 828
 829       /* Now we need to figure out where the dynamic linker was
 830          loaded so that we can load its symbols and place a breakpoint
 831          in the dynamic linker itself.  */
 832
 833       gdb_bfd_ref_ptr tmp_bfd;
 834       TRY
 835         {
 836           tmp_bfd = solib_bfd_open (buf);
 837         }
 838       CATCH (ex, RETURN_MASK_ALL)
 839         {
 840         }
 841       END_CATCH
 842
 843       if (tmp_bfd == NULL)
 844         {
 845           enable_break_failure_warning ();
 846           return 0;
 847         }
 848
 849       dsbt_get_initial_loadmaps ();
 850       ldm = info->interp_loadmap;
 851
 852       /* Record the relocated start and end address of the dynamic linker
 853          text and plt section for dsbt_in_dynsym_resolve_code.  */
 854       interp_sect = bfd_get_section_by_name (tmp_bfd.get (), ".text");
 855       if (interp_sect)
 856         {
 857           info->interp_text_sect_low
 858             = bfd_section_vma (tmp_bfd.get (), interp_sect);
 859           info->interp_text_sect_low
 860             += displacement_from_map (ldm, info->interp_text_sect_low);
 861           info->interp_text_sect_high
 862             = info->interp_text_sect_low
 863             + bfd_section_size (tmp_bfd.get (), interp_sect);
 864         }
 865       interp_sect = bfd_get_section_by_name (tmp_bfd.get (), ".plt");
 866       if (interp_sect)
 867         {
 868           info->interp_plt_sect_low =
 869             bfd_section_vma (tmp_bfd.get (), interp_sect);
 870           info->interp_plt_sect_low
 871             += displacement_from_map (ldm, info->interp_plt_sect_low);
 872           info->interp_plt_sect_high =
 873             info->interp_plt_sect_low + bfd_section_size (tmp_bfd.get (),
 874                                                           interp_sect);
 875         }
 876
 877       addr = gdb_bfd_lookup_symbol (tmp_bfd.get (), cmp_name,
 878                                     "_dl_debug_state");
 879       if (addr != 0)
 880         {
 881           if (solib_dsbt_debug)
 882             fprintf_unfiltered (gdb_stdlog,
 883                                 "enable_break: _dl_debug_state (prior to relocation) = %s\n",
 884                                 hex_string_custom (addr, 8));
 885           addr += displacement_from_map (ldm, addr);
 886
 887           if (solib_dsbt_debug)
 888             fprintf_unfiltered (gdb_stdlog,
 889                                 "enable_break: _dl_debug_state (after relocation) = %s\n",
 890                                 hex_string_custom (addr, 8));
 891
 892           /* Now (finally!) create the solib breakpoint.  */
 893           create_solib_event_breakpoint (target_gdbarch (), addr);
 894
 895           ret = 1;
 896         }
 897       else
 898         {
 899           if (solib_dsbt_debug)
 900             fprintf_unfiltered (gdb_stdlog,
 901                                 "enable_break: _dl_debug_state is not found\n");
 902           ret = 0;
 903         }
 904
 905       /* We're done with the loadmap.  */
 906       xfree (ldm);
 907
 908       return ret;
 909     }
 910
 911   /* Tell the user we couldn't set a dynamic linker breakpoint.  */
 912   enable_break_failure_warning ();
 913
 914   /* Failure return.  */
 915   return 0;
 916 }
 917
 918 static void
 919 dsbt_relocate_main_executable (void)
 920 {
 921   struct int_elf32_dsbt_loadmap *ldm;
 922   struct cleanup *old_chain;
 923   struct section_offsets *new_offsets;
 924   int changed;
 925   struct obj_section *osect;
 926   struct dsbt_info *info = get_dsbt_info ();
 927
 928   dsbt_get_initial_loadmaps ();
 929   ldm = info->exec_loadmap;
 930
 931   delete info->main_executable_lm_info;
 932   info->main_executable_lm_info = new lm_info_dsbt;
 933   info->main_executable_lm_info->map = ldm;
 934
 935   new_offsets = XCNEWVEC (struct section_offsets,
 936                           symfile_objfile->num_sections);
 937   old_chain = make_cleanup (xfree, new_offsets);
 938   changed = 0;
 939
 940   ALL_OBJFILE_OSECTIONS (symfile_objfile, osect)
 941     {
 942       CORE_ADDR orig_addr, addr, offset;
 943       int osect_idx;
 944       int seg;
 945
 946       osect_idx = osect - symfile_objfile->sections;
 947
 948       /* Current address of section.  */
 949       addr = obj_section_addr (osect);
 950       /* Offset from where this section started.  */
 951       offset = ANOFFSET (symfile_objfile->section_offsets, osect_idx);
 952       /* Original address prior to any past relocations.  */
 953       orig_addr = addr - offset;
 954
 955       for (seg = 0; seg < ldm->nsegs; seg++)
 956         {
 957           if (ldm->segs[seg].p_vaddr <= orig_addr
 958               && orig_addr < ldm->segs[seg].p_vaddr + ldm->segs[seg].p_memsz)
 959             {
 960               new_offsets->offsets[osect_idx]
 961                 = ldm->segs[seg].addr - ldm->segs[seg].p_vaddr;
 962
 963               if (new_offsets->offsets[osect_idx] != offset)
 964                 changed = 1;
 965               break;
 966             }
 967         }
 968     }
 969
 970   if (changed)
 971     objfile_relocate (symfile_objfile, new_offsets);
 972
 973   do_cleanups (old_chain);
 974
 975   /* Now that symfile_objfile has been relocated, we can compute the
 976      GOT value and stash it away.  */
 977 }
 978
 979 /* When gdb starts up the inferior, it nurses it along (through the
 980    shell) until it is ready to execute it's first instruction.  At this
 981    point, this function gets called via solib_create_inferior_hook.
 982
 983    For the DSBT shared library, the main executable needs to be relocated.
 984    The shared library breakpoints also need to be enabled.  */
 985
 986 static void
 987 dsbt_solib_create_inferior_hook (int from_tty)
 988 {
 989   /* Relocate main executable.  */
 990   dsbt_relocate_main_executable ();
 991
 992   /* Enable shared library breakpoints.  */
 993   if (!enable_break ())
 994     {
 995       warning (_("shared library handler failed to enable breakpoint"));
 996       return;
 997     }
 998 }
 999
1000 static void
1001 dsbt_clear_solib (void)
1002 {
1003   struct dsbt_info *info = get_dsbt_info ();
1004
1005   info->lm_base_cache = 0;
1006   info->main_lm_addr = 0;
1007
1008   delete info->main_executable_lm_info;
1009   info->main_executable_lm_info = NULL;
1010 }
1011
1012 static void
1013 dsbt_free_so (struct so_list *so)
1014 {
1015   lm_info_dsbt *li = (lm_info_dsbt *) so->lm_info;
1016
1017   delete li;
1018 }
1019
1020 static void
1021 dsbt_relocate_section_addresses (struct so_list *so,
1022                                  struct target_section *sec)
1023 {
1024   int seg;
1025   lm_info_dsbt *li = (lm_info_dsbt *) so->lm_info;
1026   int_elf32_dsbt_loadmap *map = li->map;
1027
1028   for (seg = 0; seg < map->nsegs; seg++)
1029     {
1030       if (map->segs[seg].p_vaddr <= sec->addr
1031           && sec->addr < map->segs[seg].p_vaddr + map->segs[seg].p_memsz)
1032         {
1033           CORE_ADDR displ = map->segs[seg].addr - map->segs[seg].p_vaddr;
1034
1035           sec->addr += displ;
1036           sec->endaddr += displ;
1037           break;
1038         }
1039     }
1040 }
1041 static void
1042 show_dsbt_debug (struct ui_file *file, int from_tty,
1043                  struct cmd_list_element *c, const char *value)
1044 {
1045   fprintf_filtered (file, _("solib-dsbt debugging is %s.\n"), value);
1046 }
1047
1048 struct target_so_ops dsbt_so_ops;
1049
1050 void
1051 _initialize_dsbt_solib (void)
1052 {
1053   solib_dsbt_pspace_data
1054     = register_program_space_data_with_cleanup (NULL, dsbt_pspace_data_cleanup);
1055
1056   dsbt_so_ops.relocate_section_addresses = dsbt_relocate_section_addresses;
1057   dsbt_so_ops.free_so = dsbt_free_so;
1058   dsbt_so_ops.clear_solib = dsbt_clear_solib;
1059   dsbt_so_ops.solib_create_inferior_hook = dsbt_solib_create_inferior_hook;
1060   dsbt_so_ops.current_sos = dsbt_current_sos;
1061   dsbt_so_ops.open_symbol_file_object = open_symbol_file_object;
1062   dsbt_so_ops.in_dynsym_resolve_code = dsbt_in_dynsym_resolve_code;
1063   dsbt_so_ops.bfd_open = solib_bfd_open;
1064
1065   /* Debug this file's internals.  */
1066   add_setshow_zuinteger_cmd ("solib-dsbt", class_maintenance,
1067                              &solib_dsbt_debug, _("\
1068 Set internal debugging of shared library code for DSBT ELF."), _("\
1069 Show internal debugging of shared library code for DSBT ELF."), _("\
1070 When non-zero, DSBT solib specific internal debugging is enabled."),
1071                              NULL,
1072                              show_dsbt_debug,
1073                              &setdebuglist, &showdebuglist);
1074 }