gdb/solib-dsbt.c

   1 /* Handle TIC6X (DSBT) shared libraries for GDB, the GNU Debugger.
   2    Copyright (C) 2010-2014 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 "exceptions.h"
  32 #include "gdb_bfd.h"
  33
  34 #define GOT_MODULE_OFFSET 4
  35
  36 /* Flag which indicates whether internal debug messages should be printed.  */
  37 static unsigned int solib_dsbt_debug = 0;
  38
  39 /* TIC6X pointers are four bytes wide.  */
  40 enum { TIC6X_PTR_SIZE = 4 };
  41
  42 /* Representation of loadmap and related structs for the TIC6X DSBT.  */
  43
  44 /* External versions; the size and alignment of the fields should be
  45    the same as those on the target.  When loaded, the placement of
  46    the bits in each field will be the same as on the target.  */
  47 typedef gdb_byte ext_Elf32_Half[2];
  48 typedef gdb_byte ext_Elf32_Addr[4];
  49 typedef gdb_byte ext_Elf32_Word[4];
  50
  51 struct ext_elf32_dsbt_loadseg
  52 {
  53   /* Core address to which the segment is mapped.  */
  54   ext_Elf32_Addr addr;
  55   /* VMA recorded in the program header.  */
  56   ext_Elf32_Addr p_vaddr;
  57   /* Size of this segment in memory.  */
  58   ext_Elf32_Word p_memsz;
  59 };
  60
  61 struct ext_elf32_dsbt_loadmap {
  62   /* Protocol version number, must be zero.  */
  63   ext_Elf32_Word version;
  64   /* A pointer to the DSBT table; the DSBT size and the index of this
  65      module.  */
  66   ext_Elf32_Word dsbt_table_ptr;
  67   ext_Elf32_Word dsbt_size;
  68   ext_Elf32_Word dsbt_index;
  69   /* Number of segments in this map.  */
  70   ext_Elf32_Word nsegs;
  71   /* The actual memory map.  */
  72   struct ext_elf32_dsbt_loadseg segs[1 /* nsegs, actually */];
  73 };
  74
  75 /* Internal versions; the types are GDB types and the data in each
  76    of the fields is (or will be) decoded from the external struct
  77    for ease of consumption.  */
  78 struct int_elf32_dsbt_loadseg
  79 {
  80   /* Core address to which the segment is mapped.  */
  81   CORE_ADDR addr;
  82   /* VMA recorded in the program header.  */
  83   CORE_ADDR p_vaddr;
  84   /* Size of this segment in memory.  */
  85   long p_memsz;
  86 };
  87
  88 struct int_elf32_dsbt_loadmap
  89 {
  90   /* Protocol version number, must be zero.  */
  91   int version;
  92   CORE_ADDR dsbt_table_ptr;
  93   /* A pointer to the DSBT table; the DSBT size and the index of this
  94      module.  */
  95   int dsbt_size, dsbt_index;
  96   /* Number of segments in this map.  */
  97   int nsegs;
  98   /* The actual memory map.  */
  99   struct int_elf32_dsbt_loadseg segs[1 /* nsegs, actually */];
 100 };
 101
 102 /* External link_map and elf32_dsbt_loadaddr struct definitions.  */
 103
 104 typedef gdb_byte ext_ptr[4];
 105
 106 struct ext_elf32_dsbt_loadaddr
 107 {
 108   ext_ptr map;                  /* struct elf32_dsbt_loadmap *map; */
 109 };
 110
 111 struct ext_link_map
 112 {
 113   struct ext_elf32_dsbt_loadaddr l_addr;
 114
 115   /* Absolute file name object was found in.  */
 116   ext_ptr l_name;               /* char *l_name; */
 117
 118   /* Dynamic section of the shared object.  */
 119   ext_ptr l_ld;                 /* ElfW(Dyn) *l_ld; */
 120
 121   /* Chain of loaded objects.  */
 122   ext_ptr l_next, l_prev;       /* struct link_map *l_next, *l_prev; */
 123 };
 124
 125 /* Link map info to include in an allocated so_list entry */
 126
 127 struct lm_info
 128 {
 129   /* The loadmap, digested into an easier to use form.  */
 130   struct int_elf32_dsbt_loadmap *map;
 131 };
 132
 133 /* Per pspace dsbt specific data.  */
 134
 135 struct dsbt_info
 136 {
 137   /* The load map, got value, etc. are not available from the chain
 138      of loaded shared objects.  ``main_executable_lm_info'' provides
 139      a way to get at this information so that it doesn't need to be
 140      frequently recomputed.  Initialized by dsbt_relocate_main_executable.  */
 141   struct lm_info *main_executable_lm_info;
 142
 143   /* Load maps for the main executable and the interpreter.  These are obtained
 144      from ptrace.  They are the starting point for getting into the program,
 145      and are required to find the solib list with the individual load maps for
 146      each module.  */
 147   struct int_elf32_dsbt_loadmap *exec_loadmap;
 148   struct int_elf32_dsbt_loadmap *interp_loadmap;
 149
 150   /* Cached value for lm_base, below.  */
 151   CORE_ADDR lm_base_cache;
 152
 153   /* Link map address for main module.  */
 154   CORE_ADDR main_lm_addr;
 155
 156   CORE_ADDR interp_text_sect_low;
 157   CORE_ADDR interp_text_sect_high;
 158   CORE_ADDR interp_plt_sect_low;
 159   CORE_ADDR interp_plt_sect_high;
 160 };
 161
 162 /* Per-program-space data key.  */
 163 static const struct program_space_data *solib_dsbt_pspace_data;
 164
 165 static void
 166 dsbt_pspace_data_cleanup (struct program_space *pspace, void *arg)
 167 {
 168   xfree (arg);
 169 }
 170
 171 /* Get the current dsbt data.  If none is found yet, add it now.  This
 172    function always returns a valid object.  */
 173
 174 static struct dsbt_info *
 175 get_dsbt_info (void)
 176 {
 177   struct dsbt_info *info;
 178
 179   info = program_space_data (current_program_space, 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 = 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 = 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 = 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 = 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 = xcalloc (1, sizeof (struct so_list));
 714           sop->lm_info = xcalloc (1, sizeof (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 (asymbol *sym, 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       volatile struct gdb_exception ex;
 825       int ret;
 826
 827       /* Read the contents of the .interp section into a local buffer;
 828          the contents specify the dynamic linker this program uses.  */
 829       interp_sect_size = bfd_section_size (exec_bfd, interp_sect);
 830       buf = alloca (interp_sect_size);
 831       bfd_get_section_contents (exec_bfd, interp_sect,
 832                                 buf, 0, interp_sect_size);
 833
 834       /* Now we need to figure out where the dynamic linker was
 835          loaded so that we can load its symbols and place a breakpoint
 836          in the dynamic linker itself.  */
 837
 838       TRY_CATCH (ex, RETURN_MASK_ALL)
 839         {
 840           tmp_bfd = solib_bfd_open (buf);
 841         }
 842       if (tmp_bfd == NULL)
 843         {
 844           enable_break_failure_warning ();
 845           return 0;
 846         }
 847
 848       dsbt_get_initial_loadmaps ();
 849       ldm = info->interp_loadmap;
 850
 851       /* Record the relocated start and end address of the dynamic linker
 852          text and plt section for dsbt_in_dynsym_resolve_code.  */
 853       interp_sect = bfd_get_section_by_name (tmp_bfd, ".text");
 854       if (interp_sect)
 855         {
 856           info->interp_text_sect_low
 857             = bfd_section_vma (tmp_bfd, interp_sect);
 858           info->interp_text_sect_low
 859             += displacement_from_map (ldm, info->interp_text_sect_low);
 860           info->interp_text_sect_high
 861             = info->interp_text_sect_low
 862             + bfd_section_size (tmp_bfd, interp_sect);
 863         }
 864       interp_sect = bfd_get_section_by_name (tmp_bfd, ".plt");
 865       if (interp_sect)
 866         {
 867           info->interp_plt_sect_low =
 868             bfd_section_vma (tmp_bfd, interp_sect);
 869           info->interp_plt_sect_low
 870             += displacement_from_map (ldm, info->interp_plt_sect_low);
 871           info->interp_plt_sect_high =
 872             info->interp_plt_sect_low + bfd_section_size (tmp_bfd, interp_sect);
 873         }
 874
 875       addr = gdb_bfd_lookup_symbol (tmp_bfd, cmp_name, "_dl_debug_state");
 876       if (addr != 0)
 877         {
 878           if (solib_dsbt_debug)
 879             fprintf_unfiltered (gdb_stdlog,
 880                                 "enable_break: _dl_debug_state (prior to relocation) = %s\n",
 881                                 hex_string_custom (addr, 8));
 882           addr += displacement_from_map (ldm, addr);
 883
 884           if (solib_dsbt_debug)
 885             fprintf_unfiltered (gdb_stdlog,
 886                                 "enable_break: _dl_debug_state (after relocation) = %s\n",
 887                                 hex_string_custom (addr, 8));
 888
 889           /* Now (finally!) create the solib breakpoint.  */
 890           create_solib_event_breakpoint (target_gdbarch (), addr);
 891
 892           ret = 1;
 893         }
 894       else
 895         {
 896           if (solib_dsbt_debug)
 897             fprintf_unfiltered (gdb_stdlog,
 898                                 "enable_break: _dl_debug_state is not found\n");
 899           ret = 0;
 900         }
 901
 902       /* We're done with the temporary bfd.  */
 903       gdb_bfd_unref (tmp_bfd);
 904
 905       /* We're also 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 /* Once the symbols from a shared object have been loaded in the usual
 919    way, we are called to do any system specific symbol handling that
 920    is needed.  */
 921
 922 static void
 923 dsbt_special_symbol_handling (void)
 924 {
 925 }
 926
 927 static void
 928 dsbt_relocate_main_executable (void)
 929 {
 930   struct int_elf32_dsbt_loadmap *ldm;
 931   struct cleanup *old_chain;
 932   struct section_offsets *new_offsets;
 933   int changed;
 934   struct obj_section *osect;
 935   struct dsbt_info *info = get_dsbt_info ();
 936
 937   dsbt_get_initial_loadmaps ();
 938   ldm = info->exec_loadmap;
 939
 940   xfree (info->main_executable_lm_info);
 941   info->main_executable_lm_info = xcalloc (1, sizeof (struct lm_info));
 942   info->main_executable_lm_info->map = ldm;
 943
 944   new_offsets = xcalloc (symfile_objfile->num_sections,
 945                          sizeof (struct section_offsets));
 946   old_chain = make_cleanup (xfree, new_offsets);
 947   changed = 0;
 948
 949   ALL_OBJFILE_OSECTIONS (symfile_objfile, osect)
 950     {
 951       CORE_ADDR orig_addr, addr, offset;
 952       int osect_idx;
 953       int seg;
 954
 955       osect_idx = osect - symfile_objfile->sections;
 956
 957       /* Current address of section.  */
 958       addr = obj_section_addr (osect);
 959       /* Offset from where this section started.  */
 960       offset = ANOFFSET (symfile_objfile->section_offsets, osect_idx);
 961       /* Original address prior to any past relocations.  */
 962       orig_addr = addr - offset;
 963
 964       for (seg = 0; seg < ldm->nsegs; seg++)
 965         {
 966           if (ldm->segs[seg].p_vaddr <= orig_addr
 967               && orig_addr < ldm->segs[seg].p_vaddr + ldm->segs[seg].p_memsz)
 968             {
 969               new_offsets->offsets[osect_idx]
 970                 = ldm->segs[seg].addr - ldm->segs[seg].p_vaddr;
 971
 972               if (new_offsets->offsets[osect_idx] != offset)
 973                 changed = 1;
 974               break;
 975             }
 976         }
 977     }
 978
 979   if (changed)
 980     objfile_relocate (symfile_objfile, new_offsets);
 981
 982   do_cleanups (old_chain);
 983
 984   /* Now that symfile_objfile has been relocated, we can compute the
 985      GOT value and stash it away.  */
 986 }
 987
 988 /* When gdb starts up the inferior, it nurses it along (through the
 989    shell) until it is ready to execute it's first instruction.  At this
 990    point, this function gets called via solib_create_inferior_hook.
 991
 992    For the DSBT shared library, the main executable needs to be relocated.
 993    The shared library breakpoints also need to be enabled.  */
 994
 995 static void
 996 dsbt_solib_create_inferior_hook (int from_tty)
 997 {
 998   /* Relocate main executable.  */
 999   dsbt_relocate_main_executable ();
1000
1001   /* Enable shared library breakpoints.  */
1002   if (!enable_break ())
1003     {
1004       warning (_("shared library handler failed to enable breakpoint"));
1005       return;
1006     }
1007 }
1008
1009 static void
1010 dsbt_clear_solib (void)
1011 {
1012   struct dsbt_info *info = get_dsbt_info ();
1013
1014   info->lm_base_cache = 0;
1015   info->main_lm_addr = 0;
1016   if (info->main_executable_lm_info != 0)
1017     {
1018       xfree (info->main_executable_lm_info->map);
1019       xfree (info->main_executable_lm_info);
1020       info->main_executable_lm_info = 0;
1021     }
1022 }
1023
1024 static void
1025 dsbt_free_so (struct so_list *so)
1026 {
1027   xfree (so->lm_info->map);
1028   xfree (so->lm_info);
1029 }
1030
1031 static void
1032 dsbt_relocate_section_addresses (struct so_list *so,
1033                                  struct target_section *sec)
1034 {
1035   int seg;
1036   struct int_elf32_dsbt_loadmap *map;
1037
1038   map = so->lm_info->map;
1039
1040   for (seg = 0; seg < map->nsegs; seg++)
1041     {
1042       if (map->segs[seg].p_vaddr <= sec->addr
1043           && sec->addr < map->segs[seg].p_vaddr + map->segs[seg].p_memsz)
1044         {
1045           CORE_ADDR displ = map->segs[seg].addr - map->segs[seg].p_vaddr;
1046
1047           sec->addr += displ;
1048           sec->endaddr += displ;
1049           break;
1050         }
1051     }
1052 }
1053 static void
1054 show_dsbt_debug (struct ui_file *file, int from_tty,
1055                  struct cmd_list_element *c, const char *value)
1056 {
1057   fprintf_filtered (file, _("solib-dsbt debugging is %s.\n"), value);
1058 }
1059
1060 struct target_so_ops dsbt_so_ops;
1061
1062 /* Provide a prototype to silence -Wmissing-prototypes.  */
1063 extern initialize_file_ftype _initialize_dsbt_solib;
1064
1065 void
1066 _initialize_dsbt_solib (void)
1067 {
1068   solib_dsbt_pspace_data
1069     = register_program_space_data_with_cleanup (NULL, dsbt_pspace_data_cleanup);
1070
1071   dsbt_so_ops.relocate_section_addresses = dsbt_relocate_section_addresses;
1072   dsbt_so_ops.free_so = dsbt_free_so;
1073   dsbt_so_ops.clear_solib = dsbt_clear_solib;
1074   dsbt_so_ops.solib_create_inferior_hook = dsbt_solib_create_inferior_hook;
1075   dsbt_so_ops.special_symbol_handling = dsbt_special_symbol_handling;
1076   dsbt_so_ops.current_sos = dsbt_current_sos;
1077   dsbt_so_ops.open_symbol_file_object = open_symbol_file_object;
1078   dsbt_so_ops.in_dynsym_resolve_code = dsbt_in_dynsym_resolve_code;
1079   dsbt_so_ops.bfd_open = solib_bfd_open;
1080
1081   /* Debug this file's internals.  */
1082   add_setshow_zuinteger_cmd ("solib-dsbt", class_maintenance,
1083                              &solib_dsbt_debug, _("\
1084 Set internal debugging of shared library code for DSBT ELF."), _("\
1085 Show internal debugging of shared library code for DSBT ELF."), _("\
1086 When non-zero, DSBT solib specific internal debugging is enabled."),
1087                              NULL,
1088                              show_dsbt_debug,
1089                              &setdebuglist, &showdebuglist);
1090 }