gdb/solib-darwin.c

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