gdb/solib-darwin.c

   1 /* Handle Darwin shared libraries for GDB, the GNU Debugger.
   2
   3    Copyright (C) 2009-2019 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 exec_bfd, get the interpreter from the load commands.  */
 196   if (exec_bfd)
 197     {
 198       bfd_mach_o_load_command *cmd;
 199
 200       if (bfd_mach_o_lookup_command (exec_bfd,
 201                                      BFD_MACH_O_LC_LOAD_DYLINKER, &cmd) == 1)
 202         return cmd->command.dylinker.name_str;
 203     }
 204
 205   /* If we didn't find it, read from memory.
 206      FIXME: todo.  */
 207   return buf;
 208 }
 209
 210 /*  Not used.  I don't see how the main symbol file can be found: the
 211     interpreter name is needed and it is known from the executable file.
 212     Note that darwin-nat.c implements pid_to_exec_file.  */
 213
 214 static int
 215 open_symbol_file_object (int from_tty)
 216 {
 217   return 0;
 218 }
 219
 220 /* Build a list of currently loaded shared objects.  See solib-svr4.c.  */
 221
 222 static struct so_list *
 223 darwin_current_sos (void)
 224 {
 225   struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
 226   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 227   int ptr_len = TYPE_LENGTH (ptr_type);
 228   unsigned int image_info_size;
 229   struct so_list *head = NULL;
 230   struct so_list *tail = NULL;
 231   int i;
 232   struct darwin_info *info = get_darwin_info ();
 233
 234   /* Be sure image infos are loaded.  */
 235   darwin_load_image_infos (info);
 236
 237   if (!darwin_dyld_version_ok (info))
 238     return NULL;
 239
 240   image_info_size = ptr_len * 3;
 241
 242   /* Read infos for each solib.
 243      The first entry was rumored to be the executable itself, but this is not
 244      true when a large number of shared libraries are used (table expanded ?).
 245      We now check all entries, but discard executable images.  */
 246   for (i = 0; i < info->all_image.count; i++)
 247     {
 248       CORE_ADDR iinfo = info->all_image.info + i * image_info_size;
 249       gdb_byte buf[image_info_size];
 250       CORE_ADDR load_addr;
 251       CORE_ADDR path_addr;
 252       struct mach_o_header_external hdr;
 253       unsigned long hdr_val;
 254       gdb::unique_xmalloc_ptr<char> file_path;
 255       int errcode;
 256
 257       /* Read image info from inferior.  */
 258       if (target_read_memory (iinfo, buf, image_info_size))
 259         break;
 260
 261       load_addr = extract_typed_address (buf, ptr_type);
 262       path_addr = extract_typed_address (buf + ptr_len, ptr_type);
 263
 264       /* Read Mach-O header from memory.  */
 265       if (target_read_memory (load_addr, (gdb_byte *) &hdr, sizeof (hdr) - 4))
 266         break;
 267       /* Discard wrong magic numbers.  Shouldn't happen.  */
 268       hdr_val = extract_unsigned_integer
 269         (hdr.magic, sizeof (hdr.magic), byte_order);
 270       if (hdr_val != BFD_MACH_O_MH_MAGIC && hdr_val != BFD_MACH_O_MH_MAGIC_64)
 271         continue;
 272       /* Discard executable.  Should happen only once.  */
 273       hdr_val = extract_unsigned_integer
 274         (hdr.filetype, sizeof (hdr.filetype), byte_order);
 275       if (hdr_val == BFD_MACH_O_MH_EXECUTE)
 276         continue;
 277
 278       target_read_string (path_addr, &file_path,
 279                           SO_NAME_MAX_PATH_SIZE - 1, &errcode);
 280       if (errcode)
 281         break;
 282
 283       /* Create and fill the new so_list element.  */
 284       gdb::unique_xmalloc_ptr<struct so_list> newobj (XCNEW (struct so_list));
 285
 286       lm_info_darwin *li = new lm_info_darwin;
 287       newobj->lm_info = li;
 288
 289       strncpy (newobj->so_name, file_path.get (), SO_NAME_MAX_PATH_SIZE - 1);
 290       newobj->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
 291       strcpy (newobj->so_original_name, newobj->so_name);
 292       li->lm_addr = load_addr;
 293
 294       if (head == NULL)
 295         head = newobj.get ();
 296       else
 297         tail->next = newobj.get ();
 298       tail = newobj.release ();
 299     }
 300
 301   return head;
 302 }
 303
 304 /* Check LOAD_ADDR points to a Mach-O executable header.  Return LOAD_ADDR
 305    in case of success, 0 in case of failure.  */
 306
 307 static CORE_ADDR
 308 darwin_validate_exec_header (CORE_ADDR load_addr)
 309 {
 310   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 311   struct mach_o_header_external hdr;
 312   unsigned long hdr_val;
 313
 314   /* Read Mach-O header from memory.  */
 315   if (target_read_memory (load_addr, (gdb_byte *) &hdr, sizeof (hdr) - 4))
 316     return 0;
 317
 318   /* Discard wrong magic numbers.  Shouldn't happen.  */
 319   hdr_val = extract_unsigned_integer
 320     (hdr.magic, sizeof (hdr.magic), byte_order);
 321   if (hdr_val != BFD_MACH_O_MH_MAGIC && hdr_val != BFD_MACH_O_MH_MAGIC_64)
 322     return 0;
 323
 324   /* Check executable.  */
 325   hdr_val = extract_unsigned_integer
 326     (hdr.filetype, sizeof (hdr.filetype), byte_order);
 327   if (hdr_val == BFD_MACH_O_MH_EXECUTE)
 328     return load_addr;
 329
 330   return 0;
 331 }
 332
 333 /* Get the load address of the executable using dyld list of images.
 334    We assume that the dyld info are correct (which is wrong if the target
 335    is stopped at the first instruction).  */
 336
 337 static CORE_ADDR
 338 darwin_read_exec_load_addr_from_dyld (struct darwin_info *info)
 339 {
 340   struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
 341   int ptr_len = TYPE_LENGTH (ptr_type);
 342   unsigned int image_info_size = ptr_len * 3;
 343   int i;
 344
 345   /* Read infos for each solib.  One of them should be the executable.  */
 346   for (i = 0; i < info->all_image.count; i++)
 347     {
 348       CORE_ADDR iinfo = info->all_image.info + i * image_info_size;
 349       gdb_byte buf[image_info_size];
 350       CORE_ADDR load_addr;
 351
 352       /* Read image info from inferior.  */
 353       if (target_read_memory (iinfo, buf, image_info_size))
 354         break;
 355
 356       load_addr = extract_typed_address (buf, ptr_type);
 357       if (darwin_validate_exec_header (load_addr) == load_addr)
 358         return load_addr;
 359     }
 360
 361   return 0;
 362 }
 363
 364 /* Get the load address of the executable when the PC is at the dyld
 365    entry point using parameter passed by the kernel (at SP). */
 366
 367 static CORE_ADDR
 368 darwin_read_exec_load_addr_at_init (struct darwin_info *info)
 369 {
 370   struct gdbarch *gdbarch = target_gdbarch ();
 371   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 372   int addr_size = gdbarch_addr_bit (gdbarch) / 8;
 373   ULONGEST load_ptr_addr;
 374   ULONGEST load_addr;
 375   gdb_byte buf[8];
 376
 377   /* Get SP.  */
 378   if (regcache_cooked_read_unsigned (get_current_regcache (),
 379                                      gdbarch_sp_regnum (gdbarch),
 380                                      &load_ptr_addr) != REG_VALID)
 381     return 0;
 382
 383   /* Read value at SP (image load address).  */
 384   if (target_read_memory (load_ptr_addr, buf, addr_size))
 385     return 0;
 386
 387   load_addr = extract_unsigned_integer (buf, addr_size, byte_order);
 388
 389   return darwin_validate_exec_header (load_addr);
 390 }
 391
 392 /* Return 1 if PC lies in the dynamic symbol resolution code of the
 393    run time loader.  */
 394
 395 static int
 396 darwin_in_dynsym_resolve_code (CORE_ADDR pc)
 397 {
 398   return 0;
 399 }
 400
 401 /* A wrapper for bfd_mach_o_fat_extract that handles reference
 402    counting properly.  This will either return NULL, or return a new
 403    reference to a BFD.  */
 404
 405 static gdb_bfd_ref_ptr
 406 gdb_bfd_mach_o_fat_extract (bfd *abfd, bfd_format format,
 407                             const bfd_arch_info_type *arch)
 408 {
 409   bfd *result = bfd_mach_o_fat_extract (abfd, format, arch);
 410
 411   if (result == NULL)
 412     return NULL;
 413
 414   if (result == abfd)
 415     gdb_bfd_ref (result);
 416   else
 417     gdb_bfd_mark_parent (result, abfd);
 418
 419   return gdb_bfd_ref_ptr (result);
 420 }
 421
 422 /* Return the BFD for the program interpreter.  */
 423
 424 static gdb_bfd_ref_ptr
 425 darwin_get_dyld_bfd ()
 426 {
 427   char *interp_name;
 428
 429   /* This method doesn't work with an attached process.  */
 430   if (current_inferior ()->attach_flag)
 431     return NULL;
 432
 433   /* Find the program interpreter.  */
 434   interp_name = find_program_interpreter ();
 435   if (!interp_name)
 436     return NULL;
 437
 438   /* Create a bfd for the interpreter.  */
 439   gdb_bfd_ref_ptr dyld_bfd (gdb_bfd_open (interp_name, gnutarget, -1));
 440   if (dyld_bfd != NULL)
 441     {
 442       gdb_bfd_ref_ptr sub
 443         (gdb_bfd_mach_o_fat_extract (dyld_bfd.get (), bfd_object,
 444                                      gdbarch_bfd_arch_info (target_gdbarch ())));
 445       dyld_bfd = sub;
 446     }
 447   return dyld_bfd;
 448 }
 449
 450 /* Extract dyld_all_image_addr when the process was just created, assuming the
 451    current PC is at the entry of the dynamic linker.  */
 452
 453 static void
 454 darwin_solib_get_all_image_info_addr_at_init (struct darwin_info *info)
 455 {
 456   CORE_ADDR load_addr = 0;
 457   gdb_bfd_ref_ptr dyld_bfd = darwin_get_dyld_bfd ();
 458
 459   if (dyld_bfd == NULL)
 460     return;
 461
 462   /* We find the dynamic linker's base address by examining
 463      the current pc (which should point at the entry point for the
 464      dynamic linker) and subtracting the offset of the entry point.  */
 465   load_addr = (regcache_read_pc (get_current_regcache ())
 466                - bfd_get_start_address (dyld_bfd.get ()));
 467
 468   /* Now try to set a breakpoint in the dynamic linker.  */
 469   info->all_image_addr =
 470     lookup_symbol_from_bfd (dyld_bfd.get (), "_dyld_all_image_infos");
 471
 472   if (info->all_image_addr == 0)
 473     return;
 474
 475   info->all_image_addr += load_addr;
 476 }
 477
 478 /* Extract dyld_all_image_addr reading it from
 479    TARGET_OBJECT_DARWIN_DYLD_INFO.  */
 480
 481 static void
 482 darwin_solib_read_all_image_info_addr (struct darwin_info *info)
 483 {
 484   gdb_byte buf[8];
 485   LONGEST len;
 486   struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
 487
 488   /* Sanity check.  */
 489   if (TYPE_LENGTH (ptr_type) > sizeof (buf))
 490     return;
 491
 492   len = target_read (current_top_target (), 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   struct darwin_info *info = get_darwin_info ();
 508   CORE_ADDR load_addr;
 509
 510   info->all_image_addr = 0;
 511
 512   darwin_solib_read_all_image_info_addr (info);
 513
 514   if (info->all_image_addr == 0)
 515     darwin_solib_get_all_image_info_addr_at_init (info);
 516
 517   if (info->all_image_addr == 0)
 518     return;
 519
 520   darwin_load_image_infos (info);
 521
 522   if (!darwin_dyld_version_ok (info))
 523     {
 524       warning (_("unhandled dyld version (%d)"), info->all_image.version);
 525       return;
 526     }
 527
 528   if (info->all_image.count != 0)
 529     {
 530       /* Possible relocate the main executable (PIE).  */
 531       load_addr = darwin_read_exec_load_addr_from_dyld (info);
 532     }
 533   else
 534     {
 535       /* Possible issue:
 536          Do not break on the notifier if dyld is not initialized (deduced from
 537          count == 0).  In that case, dyld hasn't relocated itself and the
 538          notifier may point to a wrong address.  */
 539
 540       load_addr = darwin_read_exec_load_addr_at_init (info);
 541     }
 542
 543   if (load_addr != 0 && symfile_objfile != NULL)
 544     {
 545       CORE_ADDR vmaddr;
 546
 547       /* Find the base address of the executable.  */
 548       vmaddr = bfd_mach_o_get_base_address (exec_bfd);
 549
 550       /* Relocate.  */
 551       if (vmaddr != load_addr)
 552         objfile_rebase (symfile_objfile, load_addr - vmaddr);
 553     }
 554
 555   /* Set solib notifier (to reload list of shared libraries).  */
 556   CORE_ADDR notifier = info->all_image.notifier;
 557
 558   if (info->all_image.count == 0)
 559     {
 560       /* Dyld hasn't yet relocated itself, so the notifier address may
 561          be incorrect (as it has to be relocated).  */
 562       CORE_ADDR start = bfd_get_start_address (exec_bfd);
 563       if (start == 0)
 564         notifier = 0;
 565       else
 566         {
 567           gdb_bfd_ref_ptr dyld_bfd = darwin_get_dyld_bfd ();
 568           if (dyld_bfd != NULL)
 569             {
 570               CORE_ADDR dyld_bfd_start_address;
 571               CORE_ADDR dyld_relocated_base_address;
 572               CORE_ADDR pc;
 573
 574               dyld_bfd_start_address = bfd_get_start_address (dyld_bfd.get());
 575
 576               /* We find the dynamic linker's base address by examining
 577                  the current pc (which should point at the entry point
 578                  for the dynamic linker) and subtracting the offset of
 579                  the entry point.  */
 580
 581               pc = regcache_read_pc (get_current_regcache ());
 582               dyld_relocated_base_address = pc - dyld_bfd_start_address;
 583
 584               /* We get the proper notifier relocated address by
 585                  adding the dyld relocated base address to the current
 586                  notifier offset value.  */
 587
 588               notifier += dyld_relocated_base_address;
 589             }
 590         }
 591     }
 592
 593   /* Add the breakpoint which is hit by dyld when the list of solib is
 594      modified.  */
 595   if (notifier != 0)
 596     create_solib_event_breakpoint (target_gdbarch (), notifier);
 597 }
 598
 599 static void
 600 darwin_clear_solib (void)
 601 {
 602   struct darwin_info *info = get_darwin_info ();
 603
 604   info->all_image_addr = 0;
 605   info->all_image.version = 0;
 606 }
 607
 608 static void
 609 darwin_free_so (struct so_list *so)
 610 {
 611   lm_info_darwin *li = (lm_info_darwin *) so->lm_info;
 612
 613   delete li;
 614 }
 615
 616 /* The section table is built from bfd sections using bfd VMAs.
 617    Relocate these VMAs according to solib info.  */
 618
 619 static void
 620 darwin_relocate_section_addresses (struct so_list *so,
 621                                    struct target_section *sec)
 622 {
 623   lm_info_darwin *li = (lm_info_darwin *) so->lm_info;
 624
 625   sec->addr += li->lm_addr;
 626   sec->endaddr += li->lm_addr;
 627
 628   /* Best effort to set addr_high/addr_low.  This is used only by
 629      'info sharedlibary'.  */
 630   if (so->addr_high == 0)
 631     {
 632       so->addr_low = sec->addr;
 633       so->addr_high = sec->endaddr;
 634     }
 635   if (sec->endaddr > so->addr_high)
 636     so->addr_high = sec->endaddr;
 637   if (sec->addr < so->addr_low)
 638     so->addr_low = sec->addr;
 639 }
 640 \f
 641 static struct block_symbol
 642 darwin_lookup_lib_symbol (struct objfile *objfile,
 643                           const char *name,
 644                           const domain_enum domain)
 645 {
 646   return {};
 647 }
 648
 649 static gdb_bfd_ref_ptr
 650 darwin_bfd_open (const char *pathname)
 651 {
 652   int found_file;
 653
 654   /* Search for shared library file.  */
 655   gdb::unique_xmalloc_ptr<char> found_pathname
 656     = solib_find (pathname, &found_file);
 657   if (found_pathname == NULL)
 658     perror_with_name (pathname);
 659
 660   /* Open bfd for shared library.  */
 661   gdb_bfd_ref_ptr abfd (solib_bfd_fopen (found_pathname.get (), found_file));
 662
 663   gdb_bfd_ref_ptr res
 664     (gdb_bfd_mach_o_fat_extract (abfd.get (), bfd_object,
 665                                  gdbarch_bfd_arch_info (target_gdbarch ())));
 666   if (res == NULL)
 667     error (_("`%s': not a shared-library: %s"),
 668            bfd_get_filename (abfd.get ()), bfd_errmsg (bfd_get_error ()));
 669
 670   /* The current filename for fat-binary BFDs is a name generated
 671      by BFD, usually a string containing the name of the architecture.
 672      Reset its value to the actual filename.  */
 673   xfree (bfd_get_filename (res.get ()));
 674   res->filename = xstrdup (pathname);
 675
 676   return res;
 677 }
 678
 679 struct target_so_ops darwin_so_ops;
 680
 681 void
 682 _initialize_darwin_solib (void)
 683 {
 684   darwin_so_ops.relocate_section_addresses = darwin_relocate_section_addresses;
 685   darwin_so_ops.free_so = darwin_free_so;
 686   darwin_so_ops.clear_solib = darwin_clear_solib;
 687   darwin_so_ops.solib_create_inferior_hook = darwin_solib_create_inferior_hook;
 688   darwin_so_ops.current_sos = darwin_current_sos;
 689   darwin_so_ops.open_symbol_file_object = open_symbol_file_object;
 690   darwin_so_ops.in_dynsym_resolve_code = darwin_in_dynsym_resolve_code;
 691   darwin_so_ops.lookup_lib_global_symbol = darwin_lookup_lib_symbol;
 692   darwin_so_ops.bfd_open = darwin_bfd_open;
 693 }