gdb/solib-aix.c

   1 /* Copyright (C) 2013-2020 Free Software Foundation, Inc.
   2
   3    This file is part of GDB.
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 3 of the License, or
   8    (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  17
  18 #include "defs.h"
  19 #include "solib-aix.h"
  20 #include "solist.h"
  21 #include "inferior.h"
  22 #include "gdb_bfd.h"
  23 #include "gdbcore.h"
  24 #include "objfiles.h"
  25 #include "symtab.h"
  26 #include "xcoffread.h"
  27 #include "observable.h"
  28 #include "gdbcmd.h"
  29 #include "gdbsupport/scope-exit.h"
  30
  31 /* Variable controlling the output of the debugging traces for
  32    this module.  */
  33 static bool solib_aix_debug;
  34
  35 /* Our private data in struct so_list.  */
  36
  37 struct lm_info_aix : public lm_info_base
  38 {
  39   /* The name of the file mapped by the loader.  Apart from the entry
  40      for the main executable, this is usually a shared library (which,
  41      on AIX, is an archive library file, created using the "ar"
  42      command).  */
  43   std::string filename;
  44
  45   /* The name of the shared object file with the actual dynamic
  46      loading dependency.  This may be empty (Eg. main executable).  */
  47   std::string member_name;
  48
  49   /* The address in inferior memory where the text section got mapped.  */
  50   CORE_ADDR text_addr = 0;
  51
  52   /* The size of the text section, obtained via the loader data.  */
  53   ULONGEST text_size = 0;
  54
  55   /* The address in inferior memory where the data section got mapped.  */
  56   CORE_ADDR data_addr = 0;
  57
  58   /* The size of the data section, obtained via the loader data.  */
  59   ULONGEST data_size = 0;
  60 };
  61
  62 /* This module's per-inferior data.  */
  63
  64 struct solib_aix_inferior_data
  65 {
  66   /* The list of shared libraries.
  67
  68      Note that the first element of this list is always the main
  69      executable, which is not technically a shared library.  But
  70      we need that information to perform its relocation, and
  71      the same principles applied to shared libraries also apply
  72      to the main executable.  So it's simpler to keep it as part
  73      of this list.  */
  74   gdb::optional<std::vector<lm_info_aix>> library_list;
  75 };
  76
  77 /* Key to our per-inferior data.  */
  78 static inferior_key<solib_aix_inferior_data> solib_aix_inferior_data_handle;
  79
  80 /* Return this module's data for the given inferior.
  81    If none is found, add a zero'ed one now.  */
  82
  83 static struct solib_aix_inferior_data *
  84 get_solib_aix_inferior_data (struct inferior *inf)
  85 {
  86   struct solib_aix_inferior_data *data;
  87
  88   data = solib_aix_inferior_data_handle.get (inf);
  89   if (data == NULL)
  90     data = solib_aix_inferior_data_handle.emplace (inf);
  91
  92   return data;
  93 }
  94
  95 #if !defined(HAVE_LIBEXPAT)
  96
  97 /* Dummy implementation if XML support is not compiled in.  */
  98
  99 static gdb::optional<std::vector<lm_info_aix>>
 100 solib_aix_parse_libraries (const char *library)
 101 {
 102   static int have_warned;
 103
 104   if (!have_warned)
 105     {
 106       have_warned = 1;
 107       warning (_("Can not parse XML library list; XML support was disabled "
 108                  "at compile time"));
 109     }
 110
 111   return {};
 112 }
 113
 114 #else /* HAVE_LIBEXPAT */
 115
 116 #include "xml-support.h"
 117
 118 /* Handle the start of a <library> element.  */
 119
 120 static void
 121 library_list_start_library (struct gdb_xml_parser *parser,
 122                             const struct gdb_xml_element *element,
 123                             void *user_data,
 124                             std::vector<gdb_xml_value> &attributes)
 125 {
 126   std::vector<lm_info_aix> *list = (std::vector<lm_info_aix> *) user_data;
 127   lm_info_aix item;
 128   struct gdb_xml_value *attr;
 129
 130   attr = xml_find_attribute (attributes, "name");
 131   item.filename = (const char *) attr->value.get ();
 132
 133   attr = xml_find_attribute (attributes, "member");
 134   if (attr != NULL)
 135     item.member_name = (const char *) attr->value.get ();
 136
 137   attr = xml_find_attribute (attributes, "text_addr");
 138   item.text_addr = * (ULONGEST *) attr->value.get ();
 139
 140   attr = xml_find_attribute (attributes, "text_size");
 141   item.text_size = * (ULONGEST *) attr->value.get ();
 142
 143   attr = xml_find_attribute (attributes, "data_addr");
 144   item.data_addr = * (ULONGEST *) attr->value.get ();
 145
 146   attr = xml_find_attribute (attributes, "data_size");
 147   item.data_size = * (ULONGEST *) attr->value.get ();
 148
 149   list->push_back (std::move (item));
 150 }
 151
 152 /* Handle the start of a <library-list-aix> element.  */
 153
 154 static void
 155 library_list_start_list (struct gdb_xml_parser *parser,
 156                          const struct gdb_xml_element *element,
 157                          void *user_data,
 158                          std::vector<gdb_xml_value> &attributes)
 159 {
 160   char *version
 161     = (char *) xml_find_attribute (attributes, "version")->value.get ();
 162
 163   if (strcmp (version, "1.0") != 0)
 164     gdb_xml_error (parser,
 165                    _("Library list has unsupported version \"%s\""),
 166                    version);
 167 }
 168
 169 /* The allowed elements and attributes for an AIX library list
 170    described in XML format.  The root element is a <library-list-aix>.  */
 171
 172 static const struct gdb_xml_attribute library_attributes[] =
 173 {
 174   { "name", GDB_XML_AF_NONE, NULL, NULL },
 175   { "member", GDB_XML_AF_OPTIONAL, NULL, NULL },
 176   { "text_addr", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
 177   { "text_size", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
 178   { "data_addr", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
 179   { "data_size", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
 180   { NULL, GDB_XML_AF_NONE, NULL, NULL }
 181 };
 182
 183 static const struct gdb_xml_element library_list_children[] =
 184 {
 185   { "library", library_attributes, NULL,
 186     GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
 187     library_list_start_library, NULL},
 188   { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
 189 };
 190
 191 static const struct gdb_xml_attribute library_list_attributes[] =
 192 {
 193   { "version", GDB_XML_AF_NONE, NULL, NULL },
 194   { NULL, GDB_XML_AF_NONE, NULL, NULL }
 195 };
 196
 197 static const struct gdb_xml_element library_list_elements[] =
 198 {
 199   { "library-list-aix", library_list_attributes, library_list_children,
 200     GDB_XML_EF_NONE, library_list_start_list, NULL },
 201   { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
 202 };
 203
 204 /* Parse LIBRARY, a string containing the loader info in XML format,
 205    and return a vector of lm_info_aix objects.
 206
 207    Return an empty option if the parsing failed.  */
 208
 209 static gdb::optional<std::vector<lm_info_aix>>
 210 solib_aix_parse_libraries (const char *library)
 211 {
 212   std::vector<lm_info_aix> result;
 213
 214   if (gdb_xml_parse_quick (_("aix library list"), "library-list-aix.dtd",
 215                            library_list_elements, library, &result) == 0)
 216     return result;
 217
 218   return {};
 219 }
 220
 221 #endif /* HAVE_LIBEXPAT */
 222
 223 /* Return the loader info for the given inferior (INF), or an empty
 224    option if the list could not be computed.
 225
 226    Cache the result in per-inferior data, so as to avoid recomputing it
 227    each time this function is called.
 228
 229    If an error occurs while computing this list, and WARNING_MSG
 230    is not NULL, then print a warning including WARNING_MSG and
 231    a description of the error.  */
 232
 233 static gdb::optional<std::vector<lm_info_aix>> &
 234 solib_aix_get_library_list (struct inferior *inf, const char *warning_msg)
 235 {
 236   struct solib_aix_inferior_data *data;
 237
 238   /* If already computed, return the cached value.  */
 239   data = get_solib_aix_inferior_data (inf);
 240   if (data->library_list.has_value ())
 241     return data->library_list;
 242
 243   gdb::optional<gdb::char_vector> library_document
 244     = target_read_stralloc (current_top_target (), TARGET_OBJECT_LIBRARIES_AIX,
 245                             NULL);
 246   if (!library_document && warning_msg != NULL)
 247     {
 248       warning (_("%s (failed to read TARGET_OBJECT_LIBRARIES_AIX)"),
 249                warning_msg);
 250       return data->library_list;
 251     }
 252
 253   if (solib_aix_debug)
 254     fprintf_unfiltered (gdb_stdlog,
 255                         "DEBUG: TARGET_OBJECT_LIBRARIES_AIX = \n%s\n",
 256                         library_document->data ());
 257
 258   data->library_list = solib_aix_parse_libraries (library_document->data ());
 259   if (!data->library_list.has_value () && warning_msg != NULL)
 260     warning (_("%s (missing XML support?)"), warning_msg);
 261
 262   return data->library_list;
 263 }
 264
 265 /* If the .bss section's VMA is set to an address located before
 266    the end of the .data section, causing the two sections to overlap,
 267    return the overlap in bytes.  Otherwise, return zero.
 268
 269    Motivation:
 270
 271    The GNU linker sometimes sets the start address of the .bss session
 272    before the end of the .data section, making the 2 sections overlap.
 273    The loader appears to handle this situation gracefully, by simply
 274    loading the bss section right after the end of the .data section.
 275
 276    This means that the .data and the .bss sections are sometimes
 277    no longer relocated by the same amount.  The problem is that
 278    the ldinfo data does not contain any information regarding
 279    the relocation of the .bss section, assuming that it would be
 280    identical to the information provided for the .data section
 281    (this is what would normally happen if the program was linked
 282    correctly).
 283
 284    GDB therefore needs to detect those cases, and make the corresponding
 285    adjustment to the .bss section offset computed from the ldinfo data
 286    when necessary.  This function returns the adjustment amount  (or
 287    zero when no adjustment is needed).  */
 288
 289 static CORE_ADDR
 290 solib_aix_bss_data_overlap (bfd *abfd)
 291 {
 292   struct bfd_section *data_sect, *bss_sect;
 293
 294   data_sect = bfd_get_section_by_name (abfd, ".data");
 295   if (data_sect == NULL)
 296     return 0; /* No overlap possible.  */
 297
 298   bss_sect = bfd_get_section_by_name (abfd, ".bss");
 299   if (bss_sect == NULL)
 300     return 0; /* No overlap possible.  */
 301
 302   /* Assume the problem only occurs with linkers that place the .bss
 303      section after the .data section (the problem has only been
 304      observed when using the GNU linker, and the default linker
 305      script always places the .data and .bss sections in that order).  */
 306   if (bfd_section_vma (bss_sect) < bfd_section_vma (data_sect))
 307     return 0;
 308
 309   if (bfd_section_vma (bss_sect)
 310       < bfd_section_vma (data_sect) + bfd_section_size (data_sect))
 311     return (bfd_section_vma (data_sect) + bfd_section_size (data_sect)
 312             - bfd_section_vma (bss_sect));
 313
 314   return 0;
 315 }
 316
 317 /* Implement the "relocate_section_addresses" target_so_ops method.  */
 318
 319 static void
 320 solib_aix_relocate_section_addresses (struct so_list *so,
 321                                       struct target_section *sec)
 322 {
 323   struct bfd_section *bfd_sect = sec->the_bfd_section;
 324   bfd *abfd = bfd_sect->owner;
 325   const char *section_name = bfd_section_name (bfd_sect);
 326   lm_info_aix *info = (lm_info_aix *) so->lm_info;
 327
 328   if (strcmp (section_name, ".text") == 0)
 329     {
 330       sec->addr = info->text_addr;
 331       sec->endaddr = sec->addr + info->text_size;
 332
 333       /* The text address given to us by the loader contains
 334          XCOFF headers, so we need to adjust by this much.  */
 335       sec->addr += bfd_sect->filepos;
 336     }
 337   else if (strcmp (section_name, ".data") == 0)
 338     {
 339       sec->addr = info->data_addr;
 340       sec->endaddr = sec->addr + info->data_size;
 341     }
 342   else if (strcmp (section_name, ".bss") == 0)
 343     {
 344       /* The information provided by the loader does not include
 345          the address of the .bss section, but we know that it gets
 346          relocated by the same offset as the .data section.  So,
 347          compute the relocation offset for the .data section, and
 348          apply it to the .bss section as well.  If the .data section
 349          is not defined (which seems highly unlikely), do our best
 350          by assuming no relocation.  */
 351       struct bfd_section *data_sect
 352         = bfd_get_section_by_name (abfd, ".data");
 353       CORE_ADDR data_offset = 0;
 354
 355       if (data_sect != NULL)
 356         data_offset = info->data_addr - bfd_section_vma (data_sect);
 357
 358       sec->addr = bfd_section_vma (bfd_sect) + data_offset;
 359       sec->addr += solib_aix_bss_data_overlap (abfd);
 360       sec->endaddr = sec->addr + bfd_section_size (bfd_sect);
 361     }
 362   else
 363     {
 364       /* All other sections should not be relocated.  */
 365       sec->addr = bfd_section_vma (bfd_sect);
 366       sec->endaddr = sec->addr + bfd_section_size (bfd_sect);
 367     }
 368 }
 369
 370 /* Implement the "free_so" target_so_ops method.  */
 371
 372 static void
 373 solib_aix_free_so (struct so_list *so)
 374 {
 375   lm_info_aix *li = (lm_info_aix *) so->lm_info;
 376
 377   if (solib_aix_debug)
 378     fprintf_unfiltered (gdb_stdlog, "DEBUG: solib_aix_free_so (%s)\n",
 379                         so->so_name);
 380
 381   delete li;
 382 }
 383
 384 /* Implement the "clear_solib" target_so_ops method.  */
 385
 386 static void
 387 solib_aix_clear_solib (void)
 388 {
 389   /* Nothing needed.  */
 390 }
 391
 392 /* Compute and return the OBJFILE's section_offset array, using
 393    the associated loader info (INFO).  */
 394
 395 static section_offsets
 396 solib_aix_get_section_offsets (struct objfile *objfile,
 397                                lm_info_aix *info)
 398 {
 399   bfd *abfd = objfile->obfd;
 400
 401   section_offsets offsets (objfile->section_offsets.size ());
 402
 403   /* .text */
 404
 405   if (objfile->sect_index_text != -1)
 406     {
 407       struct bfd_section *sect
 408         = objfile->sections[objfile->sect_index_text].the_bfd_section;
 409
 410       offsets[objfile->sect_index_text]
 411         = info->text_addr + sect->filepos - bfd_section_vma (sect);
 412     }
 413
 414   /* .data */
 415
 416   if (objfile->sect_index_data != -1)
 417     {
 418       struct bfd_section *sect
 419         = objfile->sections[objfile->sect_index_data].the_bfd_section;
 420
 421       offsets[objfile->sect_index_data]
 422         = info->data_addr - bfd_section_vma (sect);
 423     }
 424
 425   /* .bss
 426
 427      The offset of the .bss section should be identical to the offset
 428      of the .data section.  If no .data section (which seems hard to
 429      believe it is possible), assume it is zero.  */
 430
 431   if (objfile->sect_index_bss != -1
 432       && objfile->sect_index_data != -1)
 433     {
 434       offsets[objfile->sect_index_bss]
 435         = (offsets[objfile->sect_index_data]
 436            + solib_aix_bss_data_overlap (abfd));
 437     }
 438
 439   /* All other sections should not need relocation.  */
 440
 441   return offsets;
 442 }
 443
 444 /* Implement the "solib_create_inferior_hook" target_so_ops method.  */
 445
 446 static void
 447 solib_aix_solib_create_inferior_hook (int from_tty)
 448 {
 449   const char *warning_msg = "unable to relocate main executable";
 450
 451   /* We need to relocate the main executable...  */
 452
 453   gdb::optional<std::vector<lm_info_aix>> &library_list
 454     = solib_aix_get_library_list (current_inferior (), warning_msg);
 455   if (!library_list.has_value ())
 456     return;  /* Warning already printed.  */
 457
 458   if (library_list->empty ())
 459     {
 460       warning (_("unable to relocate main executable (no info from loader)"));
 461       return;
 462     }
 463
 464   lm_info_aix &exec_info = (*library_list)[0];
 465   if (symfile_objfile != NULL)
 466     {
 467       section_offsets offsets
 468         = solib_aix_get_section_offsets (symfile_objfile, &exec_info);
 469
 470       objfile_relocate (symfile_objfile, offsets);
 471     }
 472 }
 473
 474 /* Implement the "current_sos" target_so_ops method.  */
 475
 476 static struct so_list *
 477 solib_aix_current_sos (void)
 478 {
 479   struct so_list *start = NULL, *last = NULL;
 480   int ix;
 481
 482   gdb::optional<std::vector<lm_info_aix>> &library_list
 483     = solib_aix_get_library_list (current_inferior (), NULL);
 484   if (!library_list.has_value ())
 485     return NULL;
 486
 487   /* Build a struct so_list for each entry on the list.
 488      We skip the first entry, since this is the entry corresponding
 489      to the main executable, not a shared library.  */
 490   for (ix = 1; ix < library_list->size (); ix++)
 491     {
 492       struct so_list *new_solib = XCNEW (struct so_list);
 493       std::string so_name;
 494
 495       lm_info_aix &info = (*library_list)[ix];
 496       if (info.member_name.empty ())
 497         {
 498          /* INFO.FILENAME is probably not an archive, but rather
 499             a shared object.  Unusual, but it should be possible
 500             to link a program against a shared object directory,
 501             without having to put it in an archive first.  */
 502          so_name = info.filename;
 503         }
 504       else
 505         {
 506          /* This is the usual case on AIX, where the shared object
 507             is a member of an archive.  Create a synthetic so_name
 508             that follows the same convention as AIX's ldd tool
 509             (Eg: "/lib/libc.a(shr.o)").  */
 510          so_name = string_printf ("%s(%s)", info.filename.c_str (),
 511                                   info.member_name.c_str ());
 512         }
 513       strncpy (new_solib->so_original_name, so_name.c_str (),
 514                SO_NAME_MAX_PATH_SIZE - 1);
 515       new_solib->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
 516       memcpy (new_solib->so_name, new_solib->so_original_name,
 517               SO_NAME_MAX_PATH_SIZE);
 518       new_solib->lm_info = new lm_info_aix (info);
 519
 520       /* Add it to the list.  */
 521       if (!start)
 522         last = start = new_solib;
 523       else
 524         {
 525           last->next = new_solib;
 526           last = new_solib;
 527         }
 528     }
 529
 530   return start;
 531 }
 532
 533 /* Implement the "open_symbol_file_object" target_so_ops method.  */
 534
 535 static int
 536 solib_aix_open_symbol_file_object (int from_tty)
 537 {
 538   return 0;
 539 }
 540
 541 /* Implement the "in_dynsym_resolve_code" target_so_ops method.  */
 542
 543 static int
 544 solib_aix_in_dynsym_resolve_code (CORE_ADDR pc)
 545 {
 546   return 0;
 547 }
 548
 549 /* Implement the "bfd_open" target_so_ops method.  */
 550
 551 static gdb_bfd_ref_ptr
 552 solib_aix_bfd_open (const char *pathname)
 553 {
 554   /* The pathname is actually a synthetic filename with the following
 555      form: "/path/to/sharedlib(member.o)" (double-quotes excluded).
 556      split this into archive name and member name.
 557
 558      FIXME: This is a little hacky.  Perhaps we should provide access
 559      to the solib's lm_info here?  */
 560   const int path_len = strlen (pathname);
 561   const char *sep;
 562   int filename_len;
 563   int found_file;
 564
 565   if (pathname[path_len - 1] != ')')
 566     return solib_bfd_open (pathname);
 567
 568   /* Search for the associated parens.  */
 569   sep = strrchr (pathname, '(');
 570   if (sep == NULL)
 571     {
 572       /* Should never happen, but recover as best as we can (trying
 573          to open pathname without decoding, possibly leading to
 574          a failure), rather than triggering an assert failure).  */
 575       warning (_("missing '(' in shared object pathname: %s"), pathname);
 576       return solib_bfd_open (pathname);
 577     }
 578   filename_len = sep - pathname;
 579
 580   std::string filename (string_printf ("%.*s", filename_len, pathname));
 581   std::string member_name (string_printf ("%.*s", path_len - filename_len - 2,
 582                                           sep + 1));
 583
 584   /* Calling solib_find makes certain that sysroot path is set properly
 585      if program has a dependency on .a archive and sysroot is set via
 586      set sysroot command.  */
 587   gdb::unique_xmalloc_ptr<char> found_pathname
 588     = solib_find (filename.c_str (), &found_file);
 589   if (found_pathname == NULL)
 590       perror_with_name (pathname);
 591   gdb_bfd_ref_ptr archive_bfd (solib_bfd_fopen (found_pathname.get (),
 592                                                 found_file));
 593   if (archive_bfd == NULL)
 594     {
 595       warning (_("Could not open `%s' as an executable file: %s"),
 596                filename.c_str (), bfd_errmsg (bfd_get_error ()));
 597       return NULL;
 598     }
 599
 600   if (bfd_check_format (archive_bfd.get (), bfd_object))
 601     return archive_bfd;
 602
 603   if (! bfd_check_format (archive_bfd.get (), bfd_archive))
 604     {
 605       warning (_("\"%s\": not in executable format: %s."),
 606                filename.c_str (), bfd_errmsg (bfd_get_error ()));
 607       return NULL;
 608     }
 609
 610   gdb_bfd_ref_ptr object_bfd
 611     (gdb_bfd_openr_next_archived_file (archive_bfd.get (), NULL));
 612   while (object_bfd != NULL)
 613     {
 614       if (member_name == object_bfd->filename)
 615         break;
 616
 617       object_bfd = gdb_bfd_openr_next_archived_file (archive_bfd.get (),
 618                                                      object_bfd.get ());
 619     }
 620
 621   if (object_bfd == NULL)
 622     {
 623       warning (_("\"%s\": member \"%s\" missing."), filename.c_str (),
 624                member_name.c_str ());
 625       return NULL;
 626     }
 627
 628   if (! bfd_check_format (object_bfd.get (), bfd_object))
 629     {
 630       warning (_("%s(%s): not in object format: %s."),
 631                filename.c_str (), member_name.c_str (),
 632                bfd_errmsg (bfd_get_error ()));
 633       return NULL;
 634     }
 635
 636   /* Override the returned bfd's name with the name returned from solib_find
 637      along with appended parenthesized member name in order to allow commands
 638      listing all shared libraries to display.  Otherwise, we would only be
 639      displaying the name of the archive member object.  */
 640   bfd_set_filename (object_bfd.get (),
 641                     xstrprintf ("%s%s",
 642                                 bfd_get_filename (archive_bfd.get ()),
 643                                 sep));
 644
 645   return object_bfd;
 646 }
 647
 648 /* Return the obj_section corresponding to OBJFILE's data section,
 649    or NULL if not found.  */
 650 /* FIXME: Define in a more general location? */
 651
 652 static struct obj_section *
 653 data_obj_section_from_objfile (struct objfile *objfile)
 654 {
 655   struct obj_section *osect;
 656
 657   ALL_OBJFILE_OSECTIONS (objfile, osect)
 658     if (strcmp (bfd_section_name (osect->the_bfd_section), ".data") == 0)
 659       return osect;
 660
 661   return NULL;
 662 }
 663
 664 /* Return the TOC value corresponding to the given PC address,
 665    or raise an error if the value could not be determined.  */
 666
 667 CORE_ADDR
 668 solib_aix_get_toc_value (CORE_ADDR pc)
 669 {
 670   struct obj_section *pc_osect = find_pc_section (pc);
 671   struct obj_section *data_osect;
 672   CORE_ADDR result;
 673
 674   if (pc_osect == NULL)
 675     error (_("unable to find TOC entry for pc %s "
 676              "(no section contains this PC)"),
 677            core_addr_to_string (pc));
 678
 679   data_osect = data_obj_section_from_objfile (pc_osect->objfile);
 680   if (data_osect == NULL)
 681     error (_("unable to find TOC entry for pc %s "
 682              "(%s has no data section)"),
 683            core_addr_to_string (pc), objfile_name (pc_osect->objfile));
 684
 685   result = (obj_section_addr (data_osect)
 686             + xcoff_get_toc_offset (pc_osect->objfile));
 687   if (solib_aix_debug)
 688     fprintf_unfiltered (gdb_stdlog,
 689                         "DEBUG: solib_aix_get_toc_value (pc=%s) -> %s\n",
 690                         core_addr_to_string (pc),
 691                         core_addr_to_string (result));
 692
 693   return result;
 694 }
 695
 696 /* This module's normal_stop observer.  */
 697
 698 static void
 699 solib_aix_normal_stop_observer (struct bpstats *unused_1, int unused_2)
 700 {
 701   struct solib_aix_inferior_data *data
 702     = get_solib_aix_inferior_data (current_inferior ());
 703
 704   /* The inferior execution has been resumed, and it just stopped
 705      again.  This means that the list of shared libraries may have
 706      evolved.  Reset our cached value.  */
 707   data->library_list.reset ();
 708 }
 709
 710 /* Implements the "show debug aix-solib" command.  */
 711
 712 static void
 713 show_solib_aix_debug (struct ui_file *file, int from_tty,
 714                       struct cmd_list_element *c, const char *value)
 715 {
 716   fprintf_filtered (file, _("solib-aix debugging is %s.\n"), value);
 717 }
 718
 719 /* The target_so_ops for AIX targets.  */
 720 struct target_so_ops solib_aix_so_ops;
 721
 722 void
 723 _initialize_solib_aix (void)
 724 {
 725   solib_aix_so_ops.relocate_section_addresses
 726     = solib_aix_relocate_section_addresses;
 727   solib_aix_so_ops.free_so = solib_aix_free_so;
 728   solib_aix_so_ops.clear_solib = solib_aix_clear_solib;
 729   solib_aix_so_ops.solib_create_inferior_hook
 730     = solib_aix_solib_create_inferior_hook;
 731   solib_aix_so_ops.current_sos = solib_aix_current_sos;
 732   solib_aix_so_ops.open_symbol_file_object
 733     = solib_aix_open_symbol_file_object;
 734   solib_aix_so_ops.in_dynsym_resolve_code
 735     = solib_aix_in_dynsym_resolve_code;
 736   solib_aix_so_ops.bfd_open = solib_aix_bfd_open;
 737
 738   gdb::observers::normal_stop.attach (solib_aix_normal_stop_observer);
 739
 740   /* Debug this file's internals.  */
 741   add_setshow_boolean_cmd ("aix-solib", class_maintenance,
 742                            &solib_aix_debug, _("\
 743 Control the debugging traces for the solib-aix module."), _("\
 744 Show whether solib-aix debugging traces are enabled."), _("\
 745 When on, solib-aix debugging traces are enabled."),
 746                             NULL,
 747                             show_solib_aix_debug,
 748                             &setdebuglist, &showdebuglist);
 749 }