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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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 #include "gdb-stabs.h"
  37 #include "gdbcmd.h"
  38
  39 /* TODO:
  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], *re_err;
 118
 119   /* First validate our arguments.  */
 120   if ((re_err = re_comp (arg_string ? arg_string : ".")) != NULL)
 121     {
 122       error ("Invalid regexp: %s", re_err);
 123     }
 124
 125   /* If we're debugging a core file, or have attached to a running
 126      process, then som_solib_create_inferior_hook will not have been
 127      called.
 128
 129      We need to first determine if we're dealing with a dynamically
 130      linked executable.  If not, then return without an error or warning.
 131
 132      We also need to examine __dld_flags to determine if the shared library
 133      list is valid and to determine if the libraries have been privately
 134      mapped.  */
 135   if (symfile_objfile == NULL)
 136     return;
 137
 138   /* First see if the objfile was dynamically linked.  */
 139   shlib_info = bfd_get_section_by_name (symfile_objfile->obfd, "$SHLIB_INFO$");
 140   if (!shlib_info)
 141     return;
 142
 143   /* It's got a $SHLIB_INFO$ section, make sure it's not empty.  */
 144   if (bfd_section_size (symfile_objfile->obfd, shlib_info) == 0)
 145     return;
 146
 147   msymbol = lookup_minimal_symbol ("__dld_flags", NULL, NULL);
 148   if (msymbol == NULL)
 149     {
 150       error ("Unable to find __dld_flags symbol in object file.\n");
 151       return;
 152     }
 153
 154   addr = SYMBOL_VALUE_ADDRESS (msymbol);
 155   /* Read the current contents.  */
 156   status = target_read_memory (addr, buf, 4);
 157   if (status != 0)
 158     {
 159       error ("Unable to read __dld_flags\n");
 160       return;
 161     }
 162   dld_flags = extract_unsigned_integer (buf, 4);
 163
 164   /* __dld_list may not be valid.  If it's not valid tell the user.  */
 165   if ((dld_flags & 4) == 0)
 166     {
 167       error ("__dld_list is not valid according to __dld_flags.\n");
 168       return;
 169     }
 170
 171   /* If the libraries were not mapped private, warn the user.  */
 172   if ((dld_flags & 1) == 0)
 173     warning ("The shared libraries were not privately mapped; setting a\nbreakpoint in a shared library will not work until you rerun the program.\n");
 174
 175   msymbol = lookup_minimal_symbol ("__dld_list", NULL, NULL);
 176   if (!msymbol)
 177     {
 178       /* Older crt0.o files (hpux8) don't have __dld_list as a symbol,
 179          but the data is still available if you know where to look.  */
 180       msymbol = lookup_minimal_symbol ("__dld_flags", NULL, NULL);
 181       if (!msymbol)
 182         {
 183           error ("Unable to find dynamic library list.\n");
 184           return;
 185         }
 186       addr = SYMBOL_VALUE_ADDRESS (msymbol) - 8;
 187     }
 188   else
 189     addr = SYMBOL_VALUE_ADDRESS (msymbol);
 190
 191   status = target_read_memory (addr, buf, 4);
 192   if (status != 0)
 193     {
 194       error ("Unable to find dynamic library list.\n");
 195       return;
 196     }
 197
 198   addr = extract_unsigned_integer (buf, 4);
 199
 200   /* If addr is zero, then we're using an old dynamic loader which
 201      doesn't maintain __dld_list.  We'll have to use a completely
 202      different approach to get shared library information.  */
 203   if (addr == 0)
 204     goto old_dld;
 205
 206   /* Using the information in __dld_list is the preferred method
 207      to get at shared library information.  It doesn't depend on
 208      any functions in /usr/lib/end.o and has a chance of working
 209      with hpux10 when it is released.  */
 210   status = target_read_memory (addr, buf, 4);
 211   if (status != 0)
 212     {
 213       error ("Unable to find dynamic library list.\n");
 214       return;
 215     }
 216
 217   /* addr now holds the address of the first entry in the dynamic
 218      library list.  */
 219   addr = extract_unsigned_integer (buf, 4);
 220
 221   /* Now that we have a pointer to the dynamic library list, walk
 222      through it and add the symbols for each library.  */
 223
 224   so_list_tail = so_list_head;
 225   /* Find the end of the list of shared objects.  */
 226   while (so_list_tail && so_list_tail->next)
 227     so_list_tail = so_list_tail->next;
 228
 229   while (1)
 230     {
 231       CORE_ADDR name_addr, text_addr;
 232       unsigned int name_len;
 233       char *name;
 234       struct so_list *new_so;
 235       struct so_list *so_list = so_list_head;
 236       struct section_table *p;
 237       struct stat statbuf;
 238
 239       if (addr == 0)
 240         break;
 241
 242       /* Get a pointer to the name of this library.  */
 243       status = target_read_memory (addr, buf, 4);
 244       if (status != 0)
 245         goto err;
 246
 247       name_addr = extract_unsigned_integer (buf, 4);
 248       name_len = 0;
 249       while (1)
 250         {
 251           target_read_memory (name_addr + name_len, buf, 1);
 252           if (status != 0)
 253             goto err;
 254
 255           name_len++;
 256           if (*buf == '\0')
 257             break;
 258         }
 259       name = alloca (name_len);
 260       status = target_read_memory (name_addr, name, name_len);
 261       if (status != 0)
 262         goto err;
 263
 264       /* See if we've already loaded something with this name.  */
 265       while (so_list)
 266         {
 267           if (!strcmp (so_list->som_solib.name, name))
 268             break;
 269           so_list = so_list->next;
 270         }
 271
 272       /* See if the file exists.  If not, give a warning, but don't
 273          die.  */
 274       status = stat (name, &statbuf);
 275       if (status == -1)
 276         {
 277           warning ("Can't find file %s referenced in dld_list.", name);
 278
 279           status = target_read_memory (addr + 36, buf, 4);
 280           if (status != 0)
 281             goto err;
 282
 283           addr = (CORE_ADDR) extract_unsigned_integer (buf, 4);
 284           continue;
 285         }
 286
 287       /* If we've already loaded this one or it's the main program, skip it.  */
 288       if (so_list || !strcmp (name, symfile_objfile->name))
 289         {
 290           status = target_read_memory (addr + 36, buf, 4);
 291           if (status != 0)
 292             goto err;
 293
 294           addr = (CORE_ADDR) extract_unsigned_integer (buf, 4);
 295           continue;
 296         }
 297
 298       name = obsavestring (name, name_len - 1,
 299                            &symfile_objfile->symbol_obstack);
 300
 301       status = target_read_memory (addr + 8, buf, 4);
 302       if (status != 0)
 303         goto err;
 304
 305       text_addr = extract_unsigned_integer (buf, 4);
 306
 307
 308       new_so = (struct so_list *) malloc (sizeof (struct so_list));
 309       memset ((char *)new_so, 0, sizeof (struct so_list));
 310       if (so_list_head == NULL)
 311         {
 312           so_list_head = new_so;
 313           so_list_tail = new_so;
 314         }
 315       else
 316         {
 317           so_list_tail->next = new_so;
 318           so_list_tail = new_so;
 319         }
 320
 321       /* Fill in all the entries in GDB's shared library list.  */
 322       new_so->som_solib.name = name;
 323       status = target_read_memory (addr + 4, buf, 4);
 324       if (status != 0)
 325         goto err;
 326
 327       new_so->som_solib.struct_version = extract_unsigned_integer (buf + 3, 1);
 328       new_so->som_solib.bind_mode = extract_unsigned_integer (buf + 2, 1);
 329       new_so->som_solib.library_version = extract_unsigned_integer (buf, 2);
 330       new_so->som_solib.text_addr = text_addr;
 331
 332       status = target_read_memory (addr + 12, buf, 4);
 333       if (status != 0)
 334         goto err;
 335
 336       new_so->som_solib.text_link_addr = extract_unsigned_integer (buf, 4);
 337
 338       status = target_read_memory (addr + 16, buf, 4);
 339       if (status != 0)
 340         goto err;
 341
 342       new_so->som_solib.text_end = extract_unsigned_integer (buf, 4);
 343
 344       status = target_read_memory (addr + 20, buf, 4);
 345       if (status != 0)
 346         goto err;
 347
 348       new_so->som_solib.data_start = extract_unsigned_integer (buf, 4);
 349
 350       status = target_read_memory (addr + 24, buf, 4);
 351       if (status != 0)
 352         goto err;
 353
 354       new_so->som_solib.bss_start = extract_unsigned_integer (buf, 4);
 355
 356       status = target_read_memory (addr + 28, buf, 4);
 357       if (status != 0)
 358         goto err;
 359
 360       new_so->som_solib.data_end = extract_unsigned_integer (buf, 4);
 361
 362       status = target_read_memory (addr + 32, buf, 4);
 363       if (status != 0)
 364         goto err;
 365
 366       new_so->som_solib.got_value = extract_unsigned_integer (buf, 4);
 367
 368       status = target_read_memory (addr + 36, buf, 4);
 369       if (status != 0)
 370         goto err;
 371
 372       new_so->som_solib.next = (void *)extract_unsigned_integer (buf, 4);
 373       addr = (CORE_ADDR)new_so->som_solib.next;
 374
 375       new_so->objfile = symbol_file_add (name, from_tty, text_addr, 0, 0, 0);
 376       new_so->abfd = new_so->objfile->obfd;
 377
 378       if (!bfd_check_format (new_so->abfd, bfd_object))
 379         {
 380           error ("\"%s\": not in executable format: %s.",
 381                  name, bfd_errmsg (bfd_get_error ()));
 382         }
 383
 384       /* Now we need to build a section table for this library since
 385          we might be debugging a core file from a dynamically linked
 386          executable in which the libraries were not privately mapped.  */
 387       if (build_section_table (new_so->abfd,
 388                                &new_so->sections,
 389                                &new_so->sections_end))
 390         {
 391           error ("Unable to build section table for shared library\n.");
 392           return;
 393         }
 394
 395       /* Relocate all the sections based on where they got loaded.  */
 396       for (p = new_so->sections; p < new_so->sections_end; p++)
 397         {
 398           if (p->the_bfd_section->flags & SEC_CODE)
 399             {
 400               p->addr += text_addr - new_so->som_solib.text_link_addr;
 401               p->endaddr += text_addr - new_so->som_solib.text_link_addr;
 402             }
 403           else if (p->the_bfd_section->flags & SEC_DATA)
 404             {
 405               p->addr += new_so->som_solib.data_start;
 406               p->endaddr += new_so->som_solib.data_start;
 407             }
 408         }
 409
 410       /* Now see if we need to map in the text and data for this shared
 411          library (for example debugging a core file which does not use
 412          private shared libraries.).
 413
 414          Carefully peek at the first text address in the library.  If the
 415          read succeeds, then the libraries were privately mapped and were
 416          included in the core dump file.
 417
 418          If the peek failed, then the libraries were not privately mapped
 419          and are not in the core file, we'll have to read them in ourselves.  */
 420       status = target_read_memory (text_addr, buf, 4);
 421       if (status != 0)
 422         {
 423           int old, new;
 424           int update_coreops;
 425
 426           /* We must update the to_sections field in the core_ops structure
 427              here, otherwise we dereference a potential dangling pointer
 428              for each call to target_read/write_memory within this routine.  */
 429           update_coreops = core_ops.to_sections == target->to_sections;
 430
 431           new = new_so->sections_end - new_so->sections;
 432           /* Add sections from the shared library to the core target.  */
 433           if (target->to_sections)
 434             {
 435               old = target->to_sections_end - target->to_sections;
 436               target->to_sections = (struct section_table *)
 437                 xrealloc ((char *)target->to_sections,
 438                           ((sizeof (struct section_table)) * (old + new)));
 439             }
 440           else
 441             {
 442               old = 0;
 443               target->to_sections = (struct section_table *)
 444                 xmalloc ((sizeof (struct section_table)) * new);
 445             }
 446           target->to_sections_end = (target->to_sections + old + new);
 447
 448           /* Update the to_sections field in the core_ops structure
 449              if needed.  */
 450           if (update_coreops)
 451             {
 452               core_ops.to_sections = target->to_sections;
 453               core_ops.to_sections_end = target->to_sections_end;
 454             }
 455
 456           /* Copy over the old data before it gets clobbered.  */
 457           memcpy ((char *)(target->to_sections + old),
 458                   new_so->sections,
 459                   ((sizeof (struct section_table)) * new));
 460         }
 461     }
 462
 463   /* Getting new symbols may change our opinion about what is
 464      frameless.  */
 465   reinit_frame_cache ();
 466   return;
 467
 468 old_dld:
 469   error ("Debugging dynamic executables loaded via the hpux8 dld.sl is not supported.\n");
 470   return;
 471
 472 err:
 473   error ("Error while reading dynamic library list.\n");
 474   return;
 475 }
 476
 477
 478 /* This hook gets called just before the first instruction in the
 479    inferior process is executed.
 480
 481    This is our opportunity to set magic flags in the inferior so
 482    that GDB can be notified when a shared library is mapped in and
 483    to tell the dynamic linker that a private copy of the library is
 484    needed (so GDB can set breakpoints in the library).
 485
 486    __dld_flags is the location of the magic flags; as of this implementation
 487    there are 3 flags of interest:
 488
 489    bit 0 when set indicates that private copies of the libraries are needed
 490    bit 1 when set indicates that the callback hook routine is valid
 491    bit 2 when set indicates that the dynamic linker should maintain the
 492          __dld_list structure when loading/unloading libraries.
 493
 494    Note that shared libraries are not mapped in at this time, so we have
 495    run the inferior until the libraries are mapped in.  Typically this
 496    means running until the "_start" is called.  */
 497
 498 void
 499 som_solib_create_inferior_hook()
 500 {
 501   struct minimal_symbol *msymbol;
 502   unsigned int dld_flags, status;
 503   asection *shlib_info;
 504   char shadow_contents[BREAKPOINT_MAX], buf[4];
 505   CORE_ADDR anaddr;
 506
 507   if (symfile_objfile == NULL)
 508     return;
 509
 510   /* First see if the objfile was dynamically linked.  */
 511   shlib_info = bfd_get_section_by_name (symfile_objfile->obfd, "$SHLIB_INFO$");
 512   if (!shlib_info)
 513     return;
 514
 515   /* It's got a $SHLIB_INFO$ section, make sure it's not empty.  */
 516   if (bfd_section_size (symfile_objfile->obfd, shlib_info) == 0)
 517     return;
 518
 519   /* Get the address of __dld_flags, if no such symbol exists, then we can
 520      not debug the shared code.  */
 521   msymbol = lookup_minimal_symbol ("__dld_flags", NULL, NULL);
 522   if (msymbol == NULL)
 523     {
 524       error ("Unable to find __dld_flags symbol in object file.\n");
 525       return;
 526     }
 527
 528   anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
 529   /* Read the current contents.  */
 530   status = target_read_memory (anaddr, buf, 4);
 531   if (status != 0)
 532     {
 533       error ("Unable to read __dld_flags\n");
 534       return;
 535     }
 536   dld_flags = extract_unsigned_integer (buf, 4);
 537
 538   /* Turn on the flags we care about.  */
 539   dld_flags |= 0x5;
 540   store_unsigned_integer (buf, 4, dld_flags);
 541   status = target_write_memory (anaddr, buf, 4);
 542   if (status != 0)
 543     {
 544       error ("Unable to write __dld_flags\n");
 545       return;
 546     }
 547
 548   /* Now find the address of _start and set a breakpoint there.  */
 549   msymbol = lookup_minimal_symbol ("_start", NULL, symfile_objfile);
 550   if (msymbol == NULL)
 551     {
 552       error ("Unable to find _start symbol in object file.\n");
 553       return;
 554     }
 555
 556   anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
 557   if (target_insert_breakpoint (anaddr, shadow_contents))
 558     {
 559       error ("Unable to set breakpoint at _start.\n");
 560       return;
 561     }
 562
 563   /* Wipe out all knowledge of old shared libraries since their
 564      mapping can change from one exec to another!  */
 565   while (so_list_head)
 566     {
 567       struct so_list *temp;
 568
 569       free_objfile (so_list_head->objfile);
 570       temp = so_list_head;
 571       free (so_list_head);
 572       so_list_head = temp->next;
 573     }
 574
 575   /* Start the process again and wait for it to hit our breakpoint.  */
 576   clear_proceed_status ();
 577   stop_soon_quietly = 1;
 578   stop_signal = TARGET_SIGNAL_0;
 579   do
 580     {
 581       target_resume (-1, 0, stop_signal);
 582       wait_for_inferior ();
 583     }
 584   while (stop_signal != TARGET_SIGNAL_TRAP);
 585   stop_soon_quietly = 0;
 586
 587   /* All the libraries should be mapped in now.  Remove our breakpoint and
 588      read in the symbol tables from the shared libraries.  */
 589   if (target_remove_breakpoint (anaddr, shadow_contents))
 590     {
 591       error ("Unable to remove breakpoint at _start.\n");
 592       return;
 593     }
 594
 595   if (auto_solib_add_at_startup)
 596     som_solib_add ((char *) 0, 0, (struct target_ops *) 0);
 597 }
 598
 599 /* Return the GOT value for the shared library in which ADDR belongs.  If
 600    ADDR isn't in any known shared library, return zero.  */
 601
 602 CORE_ADDR
 603 som_solib_get_got_by_pc (addr)
 604      CORE_ADDR addr;
 605 {
 606   struct so_list *so_list = so_list_head;
 607   CORE_ADDR got_value = 0;
 608
 609   while (so_list)
 610     {
 611       if (so_list->som_solib.text_addr <= addr
 612           && so_list->som_solib.text_end > addr)
 613         {
 614           got_value = so_list->som_solib.got_value;
 615           break;
 616         }
 617       so_list = so_list->next;
 618     }
 619   return got_value;
 620 }
 621
 622 int
 623 som_solib_section_offsets (objfile, offsets)
 624      struct objfile *objfile;
 625      struct section_offsets *offsets;
 626 {
 627   struct so_list *so_list = so_list_head;
 628
 629   while (so_list)
 630     {
 631       /* Oh what a pain!  We need the offsets before so_list->objfile
 632          is valid.  The BFDs will never match.  Make a best guess.  */
 633       if (strstr (objfile->name, so_list->som_solib.name))
 634         {
 635           asection *private_section;
 636
 637           /* The text offset is easy.  */
 638           ANOFFSET (offsets, SECT_OFF_TEXT)
 639             = (so_list->som_solib.text_addr
 640                - so_list->som_solib.text_link_addr);
 641           ANOFFSET (offsets, SECT_OFF_RODATA)
 642             = ANOFFSET (offsets, SECT_OFF_TEXT);
 643
 644           /* We should look at presumed_dp in the SOM header, but
 645              that's not easily available.  This should be OK though.  */
 646           private_section = bfd_get_section_by_name (objfile->obfd,
 647                                                      "$PRIVATE$");
 648           if (!private_section)
 649             {
 650               warning ("Unable to find $PRIVATE$ in shared library!");
 651               ANOFFSET (offsets, SECT_OFF_DATA) = 0;
 652               ANOFFSET (offsets, SECT_OFF_BSS) = 0;
 653               return 1;
 654             }
 655           ANOFFSET (offsets, SECT_OFF_DATA)
 656             = (so_list->som_solib.data_start - private_section->vma);
 657           ANOFFSET (offsets, SECT_OFF_BSS)
 658             = ANOFFSET (offsets, SECT_OFF_DATA);
 659           return 1;
 660         }
 661       so_list = so_list->next;
 662     }
 663   return 0;
 664 }
 665
 666 /* Dump information about all the currently loaded shared libraries.  */
 667
 668 static void
 669 som_sharedlibrary_info_command (ignore, from_tty)
 670      char *ignore;
 671      int from_tty;
 672 {
 673   struct so_list *so_list = so_list_head;
 674
 675   if (exec_bfd == NULL)
 676     {
 677       printf_unfiltered ("no exec file.\n");
 678       return;
 679     }
 680
 681   if (so_list == NULL)
 682     {
 683       printf_unfiltered ("No shared libraries loaded at this time.\n");
 684       return;
 685     }
 686
 687   printf_unfiltered ("Shared Object Libraries\n");
 688   printf_unfiltered ("    %-12s%-12s%-12s%-12s%-12s%-12s\n",
 689                      "  flags", "  tstart", "   tend", "  dstart", "   dend", "   dlt");
 690   while (so_list)
 691     {
 692       unsigned int flags;
 693
 694       flags = so_list->som_solib.struct_version << 24;
 695       flags |= so_list->som_solib.bind_mode << 16;
 696       flags |= so_list->som_solib.library_version;
 697       printf_unfiltered ("%s\n", so_list->som_solib.name);
 698       printf_unfiltered ("    %-12s", local_hex_string_custom (flags, "08l"));
 699       printf_unfiltered ("%-12s",
 700               local_hex_string_custom (so_list->som_solib.text_addr, "08l"));
 701       printf_unfiltered ("%-12s",
 702               local_hex_string_custom (so_list->som_solib.text_end, "08l"));
 703       printf_unfiltered ("%-12s",
 704               local_hex_string_custom (so_list->som_solib.data_start, "08l"));
 705       printf_unfiltered ("%-12s",
 706               local_hex_string_custom (so_list->som_solib.data_end, "08l"));
 707       printf_unfiltered ("%-12s\n",
 708               local_hex_string_custom (so_list->som_solib.got_value, "08l"));
 709       so_list = so_list->next;
 710     }
 711 }
 712
 713 static void
 714 som_solib_sharedlibrary_command (args, from_tty)
 715      char *args;
 716      int from_tty;
 717 {
 718   dont_repeat ();
 719   som_solib_add (args, from_tty, (struct target_ops *) 0);
 720 }
 721
 722 void
 723 _initialize_som_solib ()
 724 {
 725   add_com ("sharedlibrary", class_files, som_solib_sharedlibrary_command,
 726            "Load shared object library symbols for files matching REGEXP.");
 727   add_info ("sharedlibrary", som_sharedlibrary_info_command,
 728             "Status of loaded shared object libraries.");
 729   add_show_from_set
 730     (add_set_cmd ("auto-solib-add", class_support, var_zinteger,
 731                   (char *) &auto_solib_add_at_startup,
 732                   "Set autoloading of shared library symbols at startup.\n\
 733 If nonzero, symbols from all shared object libraries will be loaded\n\
 734 automatically when the inferior begins execution.  Otherwise, symbols\n\
 735 must be loaded manually, using `sharedlibrary'.",
 736                   &setlist),
 737      &showlist);
 738
 739 }