gdb/solib-darwin.c

   1 /* Handle Darwin shared libraries for GDB, the GNU Debugger.
   2
   3    Copyright (C) 2009-2021 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21
  22 #include "symtab.h"
  23 #include "bfd.h"
  24 #include "symfile.h"
  25 #include "objfiles.h"
  26 #include "gdbcore.h"
  27 #include "target.h"
  28 #include "inferior.h"
  29 #include "regcache.h"
  30 #include "gdbthread.h"
  31 #include "gdb_bfd.h"
  32
  33 #include "solist.h"
  34 #include "solib.h"
  35 #include "solib-svr4.h"
  36
  37 #include "bfd-target.h"
  38 #include "elf-bfd.h"
  39 #include "exec.h"
  40 #include "auxv.h"
  41 #include "mach-o.h"
  42 #include "mach-o/external.h"
  43
  44 struct gdb_dyld_image_info
  45 {
  46   /* Base address (which corresponds to the Mach-O header).  */
  47   CORE_ADDR mach_header;
  48   /* Image file path.  */
  49   CORE_ADDR file_path;
  50   /* st.m_time of image file.  */
  51   unsigned long mtime;
  52 };
  53
  54 /* Content of inferior dyld_all_image_infos structure.
  55    See /usr/include/mach-o/dyld_images.h for the documentation.  */
  56 struct gdb_dyld_all_image_infos
  57 {
  58   /* Version (1).  */
  59   unsigned int version;
  60   /* Number of images.  */
  61   unsigned int count;
  62   /* Image description.  */
  63   CORE_ADDR info;
  64   /* Notifier (function called when a library is added or removed).  */
  65   CORE_ADDR notifier;
  66 };
  67
  68 /* Current all_image_infos version.  */
  69 #define DYLD_VERSION_MIN 1
  70 #define DYLD_VERSION_MAX 15
  71
  72 /* Per PSPACE specific data.  */
  73 struct darwin_info
  74 {
  75   /* Address of structure dyld_all_image_infos in inferior.  */
  76   CORE_ADDR all_image_addr = 0;
  77
  78   /* Gdb copy of dyld_all_info_infos.  */
  79   struct gdb_dyld_all_image_infos all_image {};
  80 };
  81
  82 /* Per-program-space data key.  */
  83 static program_space_key<darwin_info> solib_darwin_pspace_data;
  84
  85 /* Get the current darwin data.  If none is found yet, add it now.  This
  86    function always returns a valid object.  */
  87
  88 static struct darwin_info *
  89 get_darwin_info (void)
  90 {
  91   struct darwin_info *info;
  92
  93   info = solib_darwin_pspace_data.get (current_program_space);
  94   if (info != NULL)
  95     return info;
  96
  97   return solib_darwin_pspace_data.emplace (current_program_space);
  98 }
  99
 100 /* Return non-zero if the version in dyld_all_image is known.  */
 101
 102 static int
 103 darwin_dyld_version_ok (const struct darwin_info *info)
 104 {
 105   return info->all_image.version >= DYLD_VERSION_MIN
 106     && info->all_image.version <= DYLD_VERSION_MAX;
 107 }
 108
 109 /* Read dyld_all_image from inferior.  */
 110
 111 static void
 112 darwin_load_image_infos (struct darwin_info *info)
 113 {
 114   gdb_byte buf[24];
 115   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 116   struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
 117   int len;
 118
 119   /* If the structure address is not known, don't continue.  */
 120   if (info->all_image_addr == 0)
 121     return;
 122
 123   /* The structure has 4 fields: version (4 bytes), count (4 bytes),
 124      info (pointer) and notifier (pointer).  */
 125   len = 4 + 4 + 2 * TYPE_LENGTH (ptr_type);
 126   gdb_assert (len <= sizeof (buf));
 127   memset (&info->all_image, 0, sizeof (info->all_image));
 128
 129   /* Read structure raw bytes from target.  */
 130   if (target_read_memory (info->all_image_addr, buf, len))
 131     return;
 132
 133   /* Extract the fields.  */
 134   info->all_image.version = extract_unsigned_integer (buf, 4, byte_order);
 135   if (!darwin_dyld_version_ok (info))
 136     return;
 137
 138   info->all_image.count = extract_unsigned_integer (buf + 4, 4, byte_order);
 139   info->all_image.info = extract_typed_address (buf + 8, ptr_type);
 140   info->all_image.notifier = extract_typed_address
 141     (buf + 8 + TYPE_LENGTH (ptr_type), ptr_type);
 142 }
 143
 144 /* Link map info to include in an allocated so_list entry.  */
 145
 146 struct lm_info_darwin : public lm_info_base
 147 {
 148   /* The target location of lm.  */
 149   CORE_ADDR lm_addr = 0;
 150 };
 151
 152 /* Lookup the value for a specific symbol.  */
 153
 154 static CORE_ADDR
 155 lookup_symbol_from_bfd (bfd *abfd, const char *symname)
 156 {
 157   long storage_needed;
 158   asymbol **symbol_table;
 159   unsigned int number_of_symbols;
 160   unsigned int i;
 161   CORE_ADDR symaddr = 0;
 162
 163   storage_needed = bfd_get_symtab_upper_bound (abfd);
 164
 165   if (storage_needed <= 0)
 166     return 0;
 167
 168   symbol_table = (asymbol **) xmalloc (storage_needed);
 169   number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
 170
 171   for (i = 0; i < number_of_symbols; i++)
 172     {
 173       asymbol *sym = symbol_table[i];
 174
 175       if (strcmp (sym->name, symname) == 0
 176           && (sym->section->flags & (SEC_CODE | SEC_DATA)) != 0)
 177         {
 178           /* BFD symbols are section relative.  */
 179           symaddr = sym->value + sym->section->vma;
 180           break;
 181         }
 182     }
 183   xfree (symbol_table);
 184
 185   return symaddr;
 186 }
 187
 188 /* Return program interpreter string.  */
 189
 190 static char *
 191 find_program_interpreter (void)
 192 {
 193   char *buf = NULL;
 194
 195   /* If we have an current exec_bfd, get the interpreter from the load
 196      commands.  */
 197   if (current_program_space->exec_bfd ())
 198     {
 199       bfd_mach_o_load_command *cmd;
 200
 201       if (bfd_mach_o_lookup_command (current_program_space->exec_bfd (),
 202                                      BFD_MACH_O_LC_LOAD_DYLINKER, &cmd) == 1)
 203         return cmd->command.dylinker.name_str;
 204     }
 205
 206   /* If we didn't find it, read from memory.
 207      FIXME: todo.  */
 208   return buf;
 209 }
 210
 211 /*  Not used.  I don't see how the main symbol file can be found: the
 212     interpreter name is needed and it is known from the executable file.
 213     Note that darwin-nat.c implements pid_to_exec_file.  */
 214
 215 static int
 216 open_symbol_file_object (int from_tty)
 217 {
 218   return 0;
 219 }
 220
 221 /* Build a list of currently loaded shared objects.  See solib-svr4.c.  */
 222
 223 static struct so_list *
 224 darwin_current_sos (void)
 225 {
 226   struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
 227   enum bfd_endian byte_order = type_byte_order (ptr_type);
 228   int ptr_len = TYPE_LENGTH (ptr_type);
 229   unsigned int image_info_size;
 230   struct so_list *head = NULL;
 231   struct so_list *tail = NULL;
 232   int i;
 233   struct darwin_info *info = get_darwin_info ();
 234
 235   /* Be sure image infos are loaded.  */
 236   darwin_load_image_infos (info);
 237
 238   if (!darwin_dyld_version_ok (info))
 239     return NULL;
 240
 241   image_info_size = ptr_len * 3;
 242
 243   /* Read infos for each solib.
 244      The first entry was rumored to be the executable itself, but this is not
 245      true when a large number of shared libraries are used (table expanded ?).
 246      We now check all entries, but discard executable images.  */
 247   for (i = 0; i < info->all_image.count; i++)
 248     {
 249       CORE_ADDR iinfo = info->all_image.info + i * image_info_size;
 250       gdb_byte buf[image_info_size];
 251       CORE_ADDR load_addr;
 252       CORE_ADDR path_addr;
 253       struct mach_o_header_external hdr;
 254       unsigned long hdr_val;
 255
 256       /* Read image info from inferior.  */
 257       if (target_read_memory (iinfo, buf, image_info_size))
 258         break;
 259
 260       load_addr = extract_typed_address (buf, ptr_type);
 261       path_addr = extract_typed_address (buf + ptr_len, ptr_type);
 262
 263       /* Read Mach-O header from memory.  */
 264       if (target_read_memory (load_addr, (gdb_byte *) &hdr, sizeof (hdr) - 4))
 265         break;
 266       /* Discard wrong magic numbers.  Shouldn't happen.  */
 267       hdr_val = extract_unsigned_integer
 268         (hdr.magic, sizeof (hdr.magic), byte_order);
 269       if (hdr_val != BFD_MACH_O_MH_MAGIC && hdr_val != BFD_MACH_O_MH_MAGIC_64)
 270         continue;
 271       /* Discard executable.  Should happen only once.  */
 272       hdr_val = extract_unsigned_integer
 273         (hdr.filetype, sizeof (hdr.filetype), byte_order);
 274       if (hdr_val == BFD_MACH_O_MH_EXECUTE)
 275         continue;
 276
 277       gdb::unique_xmalloc_ptr<char> file_path
 278         = target_read_string (path_addr, SO_NAME_MAX_PATH_SIZE - 1);
 279       if (file_path == nullptr)
 280         break;
 281
 282       /* Create and fill the new so_list element.  */
 283       gdb::unique_xmalloc_ptr<struct so_list> newobj (XCNEW (struct so_list));
 284
 285       lm_info_darwin *li = new lm_info_darwin;
 286       newobj->lm_info = li;
 287
 288       strncpy (newobj->so_name, file_path.get (), SO_NAME_MAX_PATH_SIZE - 1);
 289       newobj->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
 290       strcpy (newobj->so_original_name, newobj->so_name);
 291       li->lm_addr = load_addr;
 292
 293       if (head == NULL)
 294         head = newobj.get ();
 295       else
 296         tail->next = newobj.get ();
 297       tail = newobj.release ();
 298     }
 299
 300   return head;
 301 }
 302
 303 /* Check LOAD_ADDR points to a Mach-O executable header.  Return LOAD_ADDR
 304    in case of success, 0 in case of failure.  */
 305
 306 static CORE_ADDR
 307 darwin_validate_exec_header (CORE_ADDR load_addr)
 308 {
 309   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 310   struct mach_o_header_external hdr;
 311   unsigned long hdr_val;
 312
 313   /* Read Mach-O header from memory.  */
 314   if (target_read_memory (load_addr, (gdb_byte *) &hdr, sizeof (hdr) - 4))
 315     return 0;
 316
 317   /* Discard wrong magic numbers.  Shouldn't happen.  */
 318   hdr_val = extract_unsigned_integer
 319     (hdr.magic, sizeof (hdr.magic), byte_order);
 320   if (hdr_val != BFD_MACH_O_MH_MAGIC && hdr_val != BFD_MACH_O_MH_MAGIC_64)
 321     return 0;
 322
 323   /* Check executable.  */
 324   hdr_val = extract_unsigned_integer
 325     (hdr.filetype, sizeof (hdr.filetype), byte_order);
 326   if (hdr_val == BFD_MACH_O_MH_EXECUTE)
 327     return load_addr;
 328
 329   return 0;
 330 }
 331
 332 /* Get the load address of the executable using dyld list of images.
 333    We assume that the dyld info are correct (which is wrong if the target
 334    is stopped at the first instruction).  */
 335
 336 static CORE_ADDR
 337 darwin_read_exec_load_addr_from_dyld (struct darwin_info *info)
 338 {
 339   struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
 340   int ptr_len = TYPE_LENGTH (ptr_type);
 341   unsigned int image_info_size = ptr_len * 3;
 342   int i;
 343
 344   /* Read infos for each solib.  One of them should be the executable.  */
 345   for (i = 0; i < info->all_image.count; i++)
 346     {
 347       CORE_ADDR iinfo = info->all_image.info + i * image_info_size;
 348       gdb_byte buf[image_info_size];
 349       CORE_ADDR load_addr;
 350
 351       /* Read image info from inferior.  */
 352       if (target_read_memory (iinfo, buf, image_info_size))
 353         break;
 354
 355       load_addr = extract_typed_address (buf, ptr_type);
 356       if (darwin_validate_exec_header (load_addr) == load_addr)
 357         return load_addr;
 358     }
 359
 360   return 0;
 361 }
 362
 363 /* Get the load address of the executable when the PC is at the dyld
 364    entry point using parameter passed by the kernel (at SP). */
 365
 366 static CORE_ADDR
 367 darwin_read_exec_load_addr_at_init (struct darwin_info *info)
 368 {
 369   struct gdbarch *gdbarch = target_gdbarch ();
 370   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 371   int addr_size = gdbarch_addr_bit (gdbarch) / 8;
 372   ULONGEST load_ptr_addr;
 373   ULONGEST load_addr;
 374   gdb_byte buf[8];
 375
 376   /* Get SP.  */
 377   if (regcache_cooked_read_unsigned (get_current_regcache (),
 378                                      gdbarch_sp_regnum (gdbarch),
 379                                      &load_ptr_addr) != REG_VALID)
 380     return 0;
 381
 382   /* Read value at SP (image load address).  */
 383   if (target_read_memory (load_ptr_addr, buf, addr_size))
 384     return 0;
 385
 386   load_addr = extract_unsigned_integer (buf, addr_size, byte_order);
 387
 388   return darwin_validate_exec_header (load_addr);
 389 }
 390
 391 /* Return 1 if PC lies in the dynamic symbol resolution code of the
 392    run time loader.  */
 393
 394 static int
 395 darwin_in_dynsym_resolve_code (CORE_ADDR pc)
 396 {
 397   return 0;
 398 }
 399
 400 /* A wrapper for bfd_mach_o_fat_extract that handles reference
 401    counting properly.  This will either return NULL, or return a new
 402    reference to a BFD.  */
 403
 404 static gdb_bfd_ref_ptr
 405 gdb_bfd_mach_o_fat_extract (bfd *abfd, bfd_format format,
 406                             const bfd_arch_info_type *arch)
 407 {
 408   bfd *result = bfd_mach_o_fat_extract (abfd, format, arch);
 409
 410   if (result == NULL)
 411     return NULL;
 412
 413   if (result == abfd)
 414     gdb_bfd_ref (result);
 415   else
 416     gdb_bfd_mark_parent (result, abfd);
 417
 418   return gdb_bfd_ref_ptr (result);
 419 }
 420
 421 /* Return the BFD for the program interpreter.  */
 422
 423 static gdb_bfd_ref_ptr
 424 darwin_get_dyld_bfd ()
 425 {
 426   char *interp_name;
 427
 428   /* This method doesn't work with an attached process.  */
 429   if (current_inferior ()->attach_flag)
 430     return NULL;
 431
 432   /* Find the program interpreter.  */
 433   interp_name = find_program_interpreter ();
 434   if (!interp_name)
 435     return NULL;
 436
 437   /* Create a bfd for the interpreter.  */
 438   gdb_bfd_ref_ptr dyld_bfd (gdb_bfd_open (interp_name, gnutarget));
 439   if (dyld_bfd != NULL)
 440     {
 441       gdb_bfd_ref_ptr sub
 442         (gdb_bfd_mach_o_fat_extract (dyld_bfd.get (), bfd_object,
 443                                      gdbarch_bfd_arch_info (target_gdbarch ())));
 444       dyld_bfd = sub;
 445     }
 446   return dyld_bfd;
 447 }
 448
 449 /* Extract dyld_all_image_addr when the process was just created, assuming the
 450    current PC is at the entry of the dynamic linker.  */
 451
 452 static void
 453 darwin_solib_get_all_image_info_addr_at_init (struct darwin_info *info)
 454 {
 455   CORE_ADDR load_addr = 0;
 456   gdb_bfd_ref_ptr dyld_bfd = darwin_get_dyld_bfd ();
 457
 458   if (dyld_bfd == NULL)
 459     return;
 460
 461   /* We find the dynamic linker's base address by examining
 462      the current pc (which should point at the entry point for the
 463      dynamic linker) and subtracting the offset of the entry point.  */
 464   load_addr = (regcache_read_pc (get_current_regcache ())
 465                - bfd_get_start_address (dyld_bfd.get ()));
 466
 467   /* Now try to set a breakpoint in the dynamic linker.  */
 468   info->all_image_addr =
 469     lookup_symbol_from_bfd (dyld_bfd.get (), "_dyld_all_image_infos");
 470
 471   if (info->all_image_addr == 0)
 472     return;
 473
 474   info->all_image_addr += load_addr;
 475 }
 476
 477 /* Extract dyld_all_image_addr reading it from
 478    TARGET_OBJECT_DARWIN_DYLD_INFO.  */
 479
 480 static void
 481 darwin_solib_read_all_image_info_addr (struct darwin_info *info)
 482 {
 483   gdb_byte buf[8];
 484   LONGEST len;
 485   struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
 486
 487   /* Sanity check.  */
 488   if (TYPE_LENGTH (ptr_type) > sizeof (buf))
 489     return;
 490
 491   len = target_read (current_inferior ()->top_target (),
 492                      TARGET_OBJECT_DARWIN_DYLD_INFO,
 493                      NULL, buf, 0, TYPE_LENGTH (ptr_type));
 494   if (len <= 0)
 495     return;
 496
 497   /* The use of BIG endian is intended, as BUF is a raw stream of bytes.  This
 498       makes the support of remote protocol easier.  */
 499   info->all_image_addr = extract_unsigned_integer (buf, len, BFD_ENDIAN_BIG);
 500 }
 501
 502 /* Shared library startup support.  See documentation in solib-svr4.c.  */
 503
 504 static void
 505 darwin_solib_create_inferior_hook (int from_tty)
 506 {
 507   /* Everything below only makes sense if we have a running inferior.  */
 508   if (!target_has_execution ())
 509     return;
 510
 511   struct darwin_info *info = get_darwin_info ();
 512   CORE_ADDR load_addr;
 513
 514   info->all_image_addr = 0;
 515
 516   darwin_solib_read_all_image_info_addr (info);
 517
 518   if (info->all_image_addr == 0)
 519     darwin_solib_get_all_image_info_addr_at_init (info);
 520
 521   if (info->all_image_addr == 0)
 522     return;
 523
 524   darwin_load_image_infos (info);
 525
 526   if (!darwin_dyld_version_ok (info))
 527     {
 528       warning (_("unhandled dyld version (%d)"), info->all_image.version);
 529       return;
 530     }
 531
 532   if (info->all_image.count != 0)
 533     {
 534       /* Possible relocate the main executable (PIE).  */
 535       load_addr = darwin_read_exec_load_addr_from_dyld (info);
 536     }
 537   else
 538     {
 539       /* Possible issue:
 540          Do not break on the notifier if dyld is not initialized (deduced from
 541          count == 0).  In that case, dyld hasn't relocated itself and the
 542          notifier may point to a wrong address.  */
 543
 544       load_addr = darwin_read_exec_load_addr_at_init (info);
 545     }
 546
 547   if (load_addr != 0 && current_program_space->symfile_object_file != NULL)
 548     {
 549       CORE_ADDR vmaddr;
 550
 551       /* Find the base address of the executable.  */
 552       vmaddr = bfd_mach_o_get_base_address (current_program_space->exec_bfd ());
 553
 554       /* Relocate.  */
 555       if (vmaddr != load_addr)
 556         objfile_rebase (current_program_space->symfile_object_file,
 557                         load_addr - vmaddr);
 558     }
 559
 560   /* Set solib notifier (to reload list of shared libraries).  */
 561   CORE_ADDR notifier = info->all_image.notifier;
 562
 563   if (info->all_image.count == 0)
 564     {
 565       /* Dyld hasn't yet relocated itself, so the notifier address may
 566          be incorrect (as it has to be relocated).  */
 567       CORE_ADDR start
 568         = bfd_get_start_address (current_program_space->exec_bfd ());
 569       if (start == 0)
 570         notifier = 0;
 571       else
 572         {
 573           gdb_bfd_ref_ptr dyld_bfd = darwin_get_dyld_bfd ();
 574           if (dyld_bfd != NULL)
 575             {
 576               CORE_ADDR dyld_bfd_start_address;
 577               CORE_ADDR dyld_relocated_base_address;
 578               CORE_ADDR pc;
 579
 580               dyld_bfd_start_address = bfd_get_start_address (dyld_bfd.get());
 581
 582               /* We find the dynamic linker's base address by examining
 583                  the current pc (which should point at the entry point
 584                  for the dynamic linker) and subtracting the offset of
 585                  the entry point.  */
 586
 587               pc = regcache_read_pc (get_current_regcache ());
 588               dyld_relocated_base_address = pc - dyld_bfd_start_address;
 589
 590               /* We get the proper notifier relocated address by
 591                  adding the dyld relocated base address to the current
 592                  notifier offset value.  */
 593
 594               notifier += dyld_relocated_base_address;
 595             }
 596         }
 597     }
 598
 599   /* Add the breakpoint which is hit by dyld when the list of solib is
 600      modified.  */
 601   if (notifier != 0)
 602     create_solib_event_breakpoint (target_gdbarch (), notifier);
 603 }
 604
 605 static void
 606 darwin_clear_solib (void)
 607 {
 608   struct darwin_info *info = get_darwin_info ();
 609
 610   info->all_image_addr = 0;
 611   info->all_image.version = 0;
 612 }
 613
 614 static void
 615 darwin_free_so (struct so_list *so)
 616 {
 617   lm_info_darwin *li = (lm_info_darwin *) so->lm_info;
 618
 619   delete li;
 620 }
 621
 622 /* The section table is built from bfd sections using bfd VMAs.
 623    Relocate these VMAs according to solib info.  */
 624
 625 static void
 626 darwin_relocate_section_addresses (struct so_list *so,
 627                                    struct target_section *sec)
 628 {
 629   lm_info_darwin *li = (lm_info_darwin *) so->lm_info;
 630
 631   sec->addr += li->lm_addr;
 632   sec->endaddr += li->lm_addr;
 633
 634   /* Best effort to set addr_high/addr_low.  This is used only by
 635      'info sharedlibary'.  */
 636   if (so->addr_high == 0)
 637     {
 638       so->addr_low = sec->addr;
 639       so->addr_high = sec->endaddr;
 640     }
 641   if (sec->endaddr > so->addr_high)
 642     so->addr_high = sec->endaddr;
 643   if (sec->addr < so->addr_low)
 644     so->addr_low = sec->addr;
 645 }
 646 \f
 647 static gdb_bfd_ref_ptr
 648 darwin_bfd_open (const char *pathname)
 649 {
 650   int found_file;
 651
 652   /* Search for shared library file.  */
 653   gdb::unique_xmalloc_ptr<char> found_pathname
 654     = solib_find (pathname, &found_file);
 655   if (found_pathname == NULL)
 656     perror_with_name (pathname);
 657
 658   /* Open bfd for shared library.  */
 659   gdb_bfd_ref_ptr abfd (solib_bfd_fopen (found_pathname.get (), found_file));
 660
 661   gdb_bfd_ref_ptr res
 662     (gdb_bfd_mach_o_fat_extract (abfd.get (), bfd_object,
 663                                  gdbarch_bfd_arch_info (target_gdbarch ())));
 664   if (res == NULL)
 665     error (_("`%s': not a shared-library: %s"),
 666            bfd_get_filename (abfd.get ()), bfd_errmsg (bfd_get_error ()));
 667
 668   /* The current filename for fat-binary BFDs is a name generated
 669      by BFD, usually a string containing the name of the architecture.
 670      Reset its value to the actual filename.  */
 671   bfd_set_filename (res.get (), pathname);
 672
 673   return res;
 674 }
 675
 676 struct target_so_ops darwin_so_ops;
 677
 678 void _initialize_darwin_solib ();
 679 void
 680 _initialize_darwin_solib ()
 681 {
 682   darwin_so_ops.relocate_section_addresses = darwin_relocate_section_addresses;
 683   darwin_so_ops.free_so = darwin_free_so;
 684   darwin_so_ops.clear_solib = darwin_clear_solib;
 685   darwin_so_ops.solib_create_inferior_hook = darwin_solib_create_inferior_hook;
 686   darwin_so_ops.current_sos = darwin_current_sos;
 687   darwin_so_ops.open_symbol_file_object = open_symbol_file_object;
 688   darwin_so_ops.in_dynsym_resolve_code = darwin_in_dynsym_resolve_code;
 689   darwin_so_ops.bfd_open = darwin_bfd_open;
 690 }