gdb/somsolib.c

   1 /* Handle HP SOM shared libraries for GDB, the GNU Debugger.
   2    Copyright 1993 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 2 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, write to the Free Software
  18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19
  20 Written by the Center for Software Science at the Univerity of Utah
  21 and by Cygnus Support.  */
  22
  23
  24 #include "defs.h"
  25
  26 #include "frame.h"
  27 #include "bfd.h"
  28 #include "som.h"
  29 #include "libhppa.h"
  30 #include "gdbcore.h"
  31 #include "symtab.h"
  32 #include "breakpoint.h"
  33 #include "symfile.h"
  34 #include "objfiles.h"
  35 #include "inferior.h"
  36
  37 /* TODO:
  38
  39    * Relocate data addresses in the shared library.
  40
  41    * Most of this code should work for hp300 shared libraries.  Does
  42    anyone care enough to weed out any SOM-isms.
  43
  44    * Do we need/want a command to load a shared library?
  45
  46    * Support for hpux8 dynamic linker.
  47
  48    * Support for tracking user calls to dld_load, dld_unload.  */
  49
  50 /* The basic structure which describes a dynamically loaded object.  This
  51    data structure is private to the dynamic linker and isn't found in
  52    any HPUX include file.  */
  53
  54 struct som_solib_mapped_entry
  55 {
  56   /* The name of the library.  */
  57   char *name;
  58
  59   /* Version of this structure (it is expected to change again in hpux10).  */
  60   unsigned char struct_version;
  61
  62   /* Binding mode for this library.  */
  63   unsigned char bind_mode;
  64
  65   /* Version of this library.  */
  66   short library_version;
  67
  68   /* Start of text address, link-time text location, end of text address.  */
  69   CORE_ADDR text_addr;
  70   CORE_ADDR text_link_addr;
  71   CORE_ADDR text_end;
  72
  73   /* Start of data, start of bss and end of data.  */
  74   CORE_ADDR data_start;
  75   CORE_ADDR bss_start;
  76   CORE_ADDR data_end;
  77
  78   /* Value of linkage pointer (%r19).  */
  79   CORE_ADDR got_value;
  80
  81   /* Next entry.  */
  82   struct som_solib_mapped_entry *next;
  83
  84   /* There are other fields, but I don't have information as to what is
  85      contained in them.  */
  86 };
  87
  88 /* A structure to keep track of all the known shared objects.  */
  89 struct so_list
  90 {
  91   struct som_solib_mapped_entry som_solib;
  92   struct objfile *objfile;
  93   bfd *abfd;
  94   struct section_table *sections;
  95   struct section_table *sections_end;
  96   struct so_list *next;
  97 };
  98
  99 static struct so_list *so_list_head;
 100
 101 static void som_sharedlibrary_info_command PARAMS ((char *, int));
 102
 103 /* Add symbols from shared libraries into the symtab list.  */
 104
 105 void
 106 som_solib_add (arg_string, from_tty, target)
 107      char *arg_string;
 108      int from_tty;
 109      struct target_ops *target;
 110 {
 111   struct minimal_symbol *msymbol;
 112   struct so_list *so_list_tail;
 113   CORE_ADDR addr;
 114   asection *shlib_info;
 115   int status;
 116   unsigned int dld_flags;
 117   char buf[4];
 118
 119   /* If we're debugging a core file, or have attached to a running
 120      process, then som_solib_create_inferior_hook will not have been
 121      called.
 122
 123      We need to first determine if we're dealing with a dynamically
 124      linked executable.  If not, then return without an error or warning.
 125
 126      We also need to examine __dld_flags to determine if the shared library
 127      list is valid and to determine if the libraries have been privately
 128      mapped.  */
 129   if (symfile_objfile == NULL)
 130     return;
 131
 132   /* First see if the objfile was dynamically linked.  */
 133   shlib_info = bfd_get_section_by_name (symfile_objfile->obfd, "$SHLIB_INFO$");
 134   if (!shlib_info)
 135     return;
 136
 137   /* It's got a $SHLIB_INFO$ section, make sure it's not empty.  */
 138   if (bfd_section_size (symfile_objfile->obfd, shlib_info) == 0)
 139     return;
 140
 141   msymbol = lookup_minimal_symbol ("__dld_flags", NULL, NULL);
 142   if (msymbol == NULL)
 143     {
 144       error ("Unable to find __dld_flags symbol in object file.\n");
 145       return;
 146     }
 147
 148   addr = SYMBOL_VALUE_ADDRESS (msymbol);
 149   /* Read the current contents.  */
 150   status = target_read_memory (addr, buf, 4);
 151   if (status != 0)
 152     {
 153       error ("Unable to read __dld_flags\n");
 154       return;
 155     }
 156   dld_flags = extract_unsigned_integer (buf, 4);
 157
 158   /* __dld_list may not be valid.  If it's not valid tell the user.  */
 159   if ((dld_flags & 4) == 0)
 160     {
 161       error ("__dld_list is not valid according to __dld_flags.\n");
 162       return;
 163     }
 164
 165   /* If the libraries were not mapped private, warn the user.  */
 166   if ((dld_flags & 1) == 0)
 167     warning ("The shared libraries were not privately mapped; setting a\nbreakpoint in a shared library will not work until you rerun the program.\n");
 168
 169   msymbol = lookup_minimal_symbol ("__dld_list", NULL, NULL);
 170   if (!msymbol)
 171     {
 172       /* Older crt0.o files (hpux8) don't have __dld_list as a symbol,
 173          but the data is still available if you know where to look.  */
 174       msymbol = lookup_minimal_symbol ("__dld_flags", NULL, NULL);
 175       if (!msymbol)
 176         {
 177           error ("Unable to find dynamic library list.\n");
 178           return;
 179         }
 180       addr = SYMBOL_VALUE_ADDRESS (msymbol) - 8;
 181     }
 182   else
 183     addr = SYMBOL_VALUE_ADDRESS (msymbol);
 184
 185   status = target_read_memory (addr, buf, 4);
 186   if (status != 0)
 187     {
 188       error ("Unable to find dynamic library list.\n");
 189       return;
 190     }
 191
 192   addr = extract_unsigned_integer (buf, 4);
 193
 194   /* If addr is zero, then we're using an old dynamic loader which
 195      doesn't maintain __dld_list.  We'll have to use a completely
 196      different approach to get shared library information.  */
 197   if (addr == 0)
 198     goto old_dld;
 199
 200   /* Using the information in __dld_list is the preferred method
 201      to get at shared library information.  It doesn't depend on
 202      any functions in /usr/lib/end.o and has a chance of working
 203      with hpux10 when it is released.  */
 204   status = target_read_memory (addr, buf, 4);
 205   if (status != 0)
 206     {
 207       error ("Unable to find dynamic library list.\n");
 208       return;
 209     }
 210
 211   /* addr now holds the address of the first entry in the dynamic
 212      library list.  */
 213   addr = extract_unsigned_integer (buf, 4);
 214
 215   /* Now that we have a pointer to the dynamic library list, walk
 216      through it and add the symbols for each library.
 217
 218      Skip the first entry since it's our executable.  */
 219   status = target_read_memory (addr + 36, buf, 4);
 220   if (status != 0)
 221     goto err;
 222
 223   addr = extract_unsigned_integer (buf, 4);
 224
 225   so_list_tail = so_list_head;
 226   /* Find the end of the list of shared objects.  */
 227   while (so_list_tail && so_list_tail->next)
 228     so_list_tail = so_list_tail->next;
 229
 230   while (1)
 231     {
 232       CORE_ADDR name_addr, text_addr;
 233       unsigned int name_len;
 234       char *name;
 235       struct so_list *new_so;
 236       struct section_table *p;
 237
 238       if (addr == 0)
 239         break;
 240
 241       /* Get a pointer to the name of this library.  */
 242       status = target_read_memory (addr, buf, 4);
 243       if (status != 0)
 244         goto err;
 245
 246       name_addr = extract_unsigned_integer (buf, 4);
 247       name_len = 0;
 248       while (1)
 249         {
 250           target_read_memory (name_addr + name_len, buf, 1);
 251           if (status != 0)
 252             goto err;
 253
 254           name_len++;
 255           if (*buf == '\0')
 256             break;
 257         }
 258       name = alloca (name_len);
 259       status = target_read_memory (name_addr, name, name_len);
 260       if (status != 0)
 261         goto err;
 262
 263       name = obsavestring (name, name_len - 1,
 264                            &symfile_objfile->symbol_obstack);
 265
 266       status = target_read_memory (addr + 8, buf, 4);
 267       if (status != 0)
 268         goto err;
 269
 270       text_addr = extract_unsigned_integer (buf, 4);
 271
 272
 273       new_so = (struct so_list *) malloc (sizeof (struct so_list));
 274       memset ((char *)new_so, 0, sizeof (struct so_list));
 275       if (so_list_head == NULL)
 276         {
 277           so_list_head = new_so;
 278           so_list_tail = new_so;
 279         }
 280       else
 281         {
 282           so_list_tail->next = new_so;
 283           so_list_tail = new_so;
 284         }
 285
 286       /* Fill in all the entries in GDB's shared library list.  */
 287       new_so->som_solib.name = name;
 288       status = target_read_memory (addr + 4, buf, 4);
 289       if (status != 0)
 290         goto err;
 291
 292       new_so->som_solib.struct_version = extract_unsigned_integer (buf + 3, 1);
 293       new_so->som_solib.bind_mode = extract_unsigned_integer (buf + 2, 1);
 294       new_so->som_solib.library_version = extract_unsigned_integer (buf, 2);
 295       new_so->som_solib.text_addr = text_addr;
 296
 297       status = target_read_memory (addr + 12, buf, 4);
 298       if (status != 0)
 299         goto err;
 300
 301       new_so->som_solib.text_link_addr = extract_unsigned_integer (buf, 4);
 302
 303       status = target_read_memory (addr + 16, buf, 4);
 304       if (status != 0)
 305         goto err;
 306
 307       new_so->som_solib.text_end = extract_unsigned_integer (buf, 4);
 308
 309       status = target_read_memory (addr + 20, buf, 4);
 310       if (status != 0)
 311         goto err;
 312
 313       new_so->som_solib.data_start = extract_unsigned_integer (buf, 4);
 314
 315       status = target_read_memory (addr + 24, buf, 4);
 316       if (status != 0)
 317         goto err;
 318
 319       new_so->som_solib.bss_start = extract_unsigned_integer (buf, 4);
 320
 321       status = target_read_memory (addr + 28, buf, 4);
 322       if (status != 0)
 323         goto err;
 324
 325       new_so->som_solib.data_end = extract_unsigned_integer (buf, 4);
 326
 327       status = target_read_memory (addr + 32, buf, 4);
 328       if (status != 0)
 329         goto err;
 330
 331       new_so->som_solib.got_value = extract_unsigned_integer (buf, 4);
 332
 333       status = target_read_memory (addr + 36, buf, 4);
 334       if (status != 0)
 335         goto err;
 336
 337       new_so->som_solib.next = (void *)extract_unsigned_integer (buf, 4);
 338       addr = (CORE_ADDR)new_so->som_solib.next;
 339
 340       new_so->objfile = symbol_file_add (name, from_tty, text_addr, 0, 0, 0);
 341       new_so->abfd = new_so->objfile->obfd;
 342
 343       if (!bfd_check_format (new_so->abfd, bfd_object))
 344         {
 345           error ("\"%s\": not in executable format: %s.",
 346                  name, bfd_errmsg (bfd_get_error ()));
 347         }
 348
 349       /* Now we need to build a section table for this library since
 350          we might be debugging a core file from a dynamically linked
 351          executable in which the libraries were not privately mapped.  */
 352       if (build_section_table (new_so->abfd,
 353                                &new_so->sections,
 354                                &new_so->sections_end))
 355         {
 356           error ("Unable to build section table for shared library\n.");
 357           return;
 358         }
 359
 360       /* Relocate all the sections based on where they got loaded.  */
 361       for (p = new_so->sections; p < new_so->sections_end; p++)
 362         {
 363           if (p->the_bfd_section->flags & SEC_CODE)
 364             {
 365               p->addr += text_addr - new_so->som_solib.text_link_addr;
 366               p->endaddr += text_addr - new_so->som_solib.text_link_addr;
 367             }
 368           else if (p->the_bfd_section->flags & SEC_DATA)
 369             {
 370               p->addr += new_so->som_solib.data_start;
 371               p->endaddr += new_so->som_solib.data_start;
 372             }
 373         }
 374
 375       /* Now see if we need to map in the text and data for this shared
 376          library (for example debugging a core file which does not use
 377          private shared libraries.).
 378
 379          Carefully peek at the first text address in the library.  If the
 380          read succeeds, then the libraries were privately mapped and were
 381          included in the core dump file.
 382
 383          If the peek failed, then the libraries were not privately mapped
 384          and are not in the core file, we'll have to read them in ourselves.  */
 385       status = target_read_memory (text_addr, buf, 4);
 386       if (status != 0)
 387         {
 388           int old, new;
 389
 390           new = new_so->sections_end - new_so->sections;
 391           /* Add sections from the shared library to the core target.  */
 392           if (target->to_sections)
 393             {
 394               old = target->to_sections_end - target->to_sections;
 395               target->to_sections = (struct section_table *)
 396                 xrealloc ((char *)target->to_sections,
 397                           ((sizeof (struct section_table)) * (old + new)));
 398             }
 399           else
 400             {
 401               old = 0;
 402               target->to_sections = (struct section_table *)
 403                 xmalloc ((sizeof (struct section_table)) * new);
 404             }
 405           target->to_sections_end = (target->to_sections + old + new);
 406           memcpy ((char *)(target->to_sections + old),
 407                   new_so->sections,
 408                   ((sizeof (struct section_table)) * new));
 409         }
 410     }
 411
 412   /* Getting new symbols may change our opinion about what is
 413      frameless.  */
 414   reinit_frame_cache ();
 415   return;
 416
 417 old_dld:
 418   error ("Debugging dynamic executables loaded via the hpux8 dld.sl is not supported.\n");
 419   return;
 420
 421 err:
 422   error ("Error while reading dynamic library list.\n");
 423   return;
 424 }
 425
 426
 427 /* This hook gets called just before the first instruction in the
 428    inferior process is executed.
 429
 430    This is our opportunity to set magic flags in the inferior so
 431    that GDB can be notified when a shared library is mapped in and
 432    to tell the dynamic linker that a private copy of the library is
 433    needed (so GDB can set breakpoints in the library).
 434
 435    __dld_flags is the location of the magic flags; as of this implementation
 436    there are 3 flags of interest:
 437
 438    bit 0 when set indicates that private copies of the libraries are needed
 439    bit 1 when set indicates that the callback hook routine is valid
 440    bit 2 when set indicates that the dynamic linker should maintain the
 441          __dld_list structure when loading/unloading libraries.
 442
 443    Note that shared libraries are not mapped in at this time, so we have
 444    run the inferior until the libraries are mapped in.  Typically this
 445    means running until the "_start" is called.  */
 446
 447 void
 448 som_solib_create_inferior_hook()
 449 {
 450   struct minimal_symbol *msymbol;
 451   unsigned int dld_flags, status;
 452   asection *shlib_info;
 453   char shadow_contents[BREAKPOINT_MAX], buf[4];
 454   CORE_ADDR anaddr;
 455
 456   if (symfile_objfile == NULL)
 457     return;
 458
 459   /* First see if the objfile was dynamically linked.  */
 460   shlib_info = bfd_get_section_by_name (symfile_objfile->obfd, "$SHLIB_INFO$");
 461   if (!shlib_info)
 462     return;
 463
 464   /* It's got a $SHLIB_INFO$ section, make sure it's not empty.  */
 465   if (bfd_section_size (symfile_objfile->obfd, shlib_info) == 0)
 466     return;
 467
 468   /* Get the address of __dld_flags, if no such symbol exists, then we can
 469      not debug the shared code.  */
 470   msymbol = lookup_minimal_symbol ("__dld_flags", NULL, NULL);
 471   if (msymbol == NULL)
 472     {
 473       error ("Unable to find __dld_flags symbol in object file.\n");
 474       return;
 475     }
 476
 477   anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
 478   /* Read the current contents.  */
 479   status = target_read_memory (anaddr, buf, 4);
 480   if (status != 0)
 481     {
 482       error ("Unable to read __dld_flags\n");
 483       return;
 484     }
 485   dld_flags = extract_unsigned_integer (buf, 4);
 486
 487   /* Turn on the flags we care about.  */
 488   dld_flags |= 0x5;
 489   store_unsigned_integer (buf, 4, dld_flags);
 490   status = target_write_memory (anaddr, buf, 4);
 491   if (status != 0)
 492     {
 493       error ("Unable to write __dld_flags\n");
 494       return;
 495     }
 496
 497   /* Now find the address of _start and set a breakpoint there.  */
 498   msymbol = lookup_minimal_symbol ("_start", NULL, symfile_objfile);
 499   if (msymbol == NULL)
 500     {
 501       error ("Unable to find _start symbol in object file.\n");
 502       return;
 503     }
 504
 505   anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
 506   if (target_insert_breakpoint (anaddr, shadow_contents))
 507     {
 508       error ("Unable to set breakpoint at _start.\n");
 509       return;
 510     }
 511
 512   /* Wipe out all knowledge of old shared libraries since their
 513      mapping can change from one exec to another!  */
 514   while (so_list_head)
 515     {
 516       struct so_list *temp;
 517
 518       free_objfile (so_list_head->objfile);
 519       temp = so_list_head;
 520       free (so_list_head);
 521       so_list_head = temp->next;
 522     }
 523
 524   /* Start the process again and wait for it to hit our breakpoint.  */
 525   clear_proceed_status ();
 526   stop_soon_quietly = 1;
 527   stop_signal = TARGET_SIGNAL_0;
 528   do
 529     {
 530       target_resume (-1, 0, stop_signal);
 531       wait_for_inferior ();
 532     }
 533   while (stop_signal != TARGET_SIGNAL_TRAP);
 534   stop_soon_quietly = 0;
 535
 536   /* All the libraries should be mapped in now.  Remove our breakpoint and
 537      read in the symbol tables from the shared libraries.  */
 538   if (target_remove_breakpoint (anaddr, shadow_contents))
 539     {
 540       error ("Unable to remove breakpoint at _start.\n");
 541       return;
 542     }
 543
 544   som_solib_add ((char *) 0, 0, (struct target_ops *) 0);
 545 }
 546
 547 /* Return the GOT value for the shared library in which ADDR belongs.  If
 548    ADDR isn't in any known shared library, return zero.  */
 549
 550 CORE_ADDR
 551 som_solib_get_got_by_pc (addr)
 552      CORE_ADDR addr;
 553 {
 554   struct so_list *so_list = so_list_head;
 555   CORE_ADDR got_value = 0;
 556
 557   while (so_list)
 558     {
 559       if (so_list->som_solib.text_addr <= addr
 560           && so_list->som_solib.text_end > addr)
 561         {
 562           got_value = so_list->som_solib.got_value;
 563           break;
 564         }
 565       so_list = so_list->next;
 566     }
 567   return got_value;
 568 }
 569
 570 int
 571 som_solib_section_offsets (objfile, offsets)
 572      struct objfile *objfile;
 573      struct section_offsets *offsets;
 574 {
 575   struct so_list *so_list = so_list_head;
 576
 577   while (so_list)
 578     {
 579       /* Oh what a pain!  We need the offsets before so_list->objfile
 580          is valid.  The BFDs will never match.  Make a best guess.  */
 581       if (!strcmp (so_list->som_solib.name, objfile->name))
 582         {
 583           asection *private_section;
 584
 585           /* The text offset is easy.  */
 586           ANOFFSET (offsets, 0) = (so_list->som_solib.text_addr
 587                                    - so_list->som_solib.text_link_addr);
 588
 589           /* We should look at presumed_dp in the SOM header, but
 590              that's not easily available.  This should be OK though.  */
 591           private_section = bfd_get_section_by_name (objfile->obfd,
 592                                                      "$PRIVATE$");
 593           if (!private_section)
 594             {
 595               warning ("Unable to find $PRIVATE$ in shared library!");
 596               ANOFFSET (offsets, 1) = 0;
 597               return 1;
 598             }
 599           ANOFFSET (offsets, 1) = (so_list->som_solib.data_start
 600                                    - private_section->vma);
 601           return 1;
 602         }
 603       so_list = so_list->next;
 604     }
 605   return 0;
 606 }
 607
 608 /* Dump information about all the currently loaded shared libraries.  */
 609
 610 static void
 611 som_sharedlibrary_info_command (ignore, from_tty)
 612      char *ignore;
 613      int from_tty;
 614 {
 615   struct so_list *so_list = so_list_head;
 616
 617   if (exec_bfd == NULL)
 618     {
 619       printf_unfiltered ("no exec file.\n");
 620       return;
 621     }
 622
 623   if (so_list == NULL)
 624     {
 625       printf_unfiltered ("No shared libraries loaded at this time.\n");
 626       return;
 627     }
 628
 629   printf_unfiltered ("Shared Object Libraries\n");
 630   printf_unfiltered ("    %-12s%-12s%-12s%-12s%-12s%-12s\n",
 631                      "  flags", "  tstart", "   tend", "  dstart", "   dend", "   dlt");
 632   while (so_list)
 633     {
 634       unsigned int flags;
 635
 636       flags = so_list->som_solib.struct_version << 24;
 637       flags |= so_list->som_solib.bind_mode << 16;
 638       flags |= so_list->som_solib.library_version;
 639       printf_unfiltered ("%s\n", so_list->som_solib.name);
 640       printf_unfiltered ("    %-12s", local_hex_string_custom (flags, "08l"));
 641       printf_unfiltered ("%-12s",
 642               local_hex_string_custom (so_list->som_solib.text_addr, "08l"));
 643       printf_unfiltered ("%-12s",
 644               local_hex_string_custom (so_list->som_solib.text_end, "08l"));
 645       printf_unfiltered ("%-12s",
 646               local_hex_string_custom (so_list->som_solib.data_start, "08l"));
 647       printf_unfiltered ("%-12s",
 648               local_hex_string_custom (so_list->som_solib.data_end, "08l"));
 649       printf_unfiltered ("%-12s\n",
 650               local_hex_string_custom (so_list->som_solib.got_value, "08l"));
 651       so_list = so_list->next;
 652     }
 653 }
 654
 655 void
 656 _initialize_som_solib ()
 657 {
 658   add_info ("sharedlibrary", som_sharedlibrary_info_command,
 659             "Status of loaded shared object libraries.");
 660 }