gdb/solib-darwin.c

   1 /* Handle Darwin shared libraries for GDB, the GNU Debugger.
   2
   3    Copyright (C) 2009-2020 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_top_target (), TARGET_OBJECT_DARWIN_DYLD_INFO,
 492                      NULL, buf, 0, TYPE_LENGTH (ptr_type));
 493   if (len <= 0)
 494     return;
 495
 496   /* The use of BIG endian is intended, as BUF is a raw stream of bytes.  This
 497       makes the support of remote protocol easier.  */
 498   info->all_image_addr = extract_unsigned_integer (buf, len, BFD_ENDIAN_BIG);
 499 }
 500
 501 /* Shared library startup support.  See documentation in solib-svr4.c.  */
 502
 503 static void
 504 darwin_solib_create_inferior_hook (int from_tty)
 505 {
 506   struct darwin_info *info = get_darwin_info ();
 507   CORE_ADDR load_addr;
 508
 509   info->all_image_addr = 0;
 510
 511   darwin_solib_read_all_image_info_addr (info);
 512
 513   if (info->all_image_addr == 0)
 514     darwin_solib_get_all_image_info_addr_at_init (info);
 515
 516   if (info->all_image_addr == 0)
 517     return;
 518
 519   darwin_load_image_infos (info);
 520
 521   if (!darwin_dyld_version_ok (info))
 522     {
 523       warning (_("unhandled dyld version (%d)"), info->all_image.version);
 524       return;
 525     }
 526
 527   if (info->all_image.count != 0)
 528     {
 529       /* Possible relocate the main executable (PIE).  */
 530       load_addr = darwin_read_exec_load_addr_from_dyld (info);
 531     }
 532   else
 533     {
 534       /* Possible issue:
 535          Do not break on the notifier if dyld is not initialized (deduced from
 536          count == 0).  In that case, dyld hasn't relocated itself and the
 537          notifier may point to a wrong address.  */
 538
 539       load_addr = darwin_read_exec_load_addr_at_init (info);
 540     }
 541
 542   if (load_addr != 0 && symfile_objfile != NULL)
 543     {
 544       CORE_ADDR vmaddr;
 545
 546       /* Find the base address of the executable.  */
 547       vmaddr = bfd_mach_o_get_base_address (current_program_space->exec_bfd ());
 548
 549       /* Relocate.  */
 550       if (vmaddr != load_addr)
 551         objfile_rebase (symfile_objfile, load_addr - vmaddr);
 552     }
 553
 554   /* Set solib notifier (to reload list of shared libraries).  */
 555   CORE_ADDR notifier = info->all_image.notifier;
 556
 557   if (info->all_image.count == 0)
 558     {
 559       /* Dyld hasn't yet relocated itself, so the notifier address may
 560          be incorrect (as it has to be relocated).  */
 561       CORE_ADDR start
 562         = bfd_get_start_address (current_program_space->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 gdb_bfd_ref_ptr
 642 darwin_bfd_open (const char *pathname)
 643 {
 644   int found_file;
 645
 646   /* Search for shared library file.  */
 647   gdb::unique_xmalloc_ptr<char> found_pathname
 648     = solib_find (pathname, &found_file);
 649   if (found_pathname == NULL)
 650     perror_with_name (pathname);
 651
 652   /* Open bfd for shared library.  */
 653   gdb_bfd_ref_ptr abfd (solib_bfd_fopen (found_pathname.get (), found_file));
 654
 655   gdb_bfd_ref_ptr res
 656     (gdb_bfd_mach_o_fat_extract (abfd.get (), bfd_object,
 657                                  gdbarch_bfd_arch_info (target_gdbarch ())));
 658   if (res == NULL)
 659     error (_("`%s': not a shared-library: %s"),
 660            bfd_get_filename (abfd.get ()), bfd_errmsg (bfd_get_error ()));
 661
 662   /* The current filename for fat-binary BFDs is a name generated
 663      by BFD, usually a string containing the name of the architecture.
 664      Reset its value to the actual filename.  */
 665   bfd_set_filename (res.get (), pathname);
 666
 667   return res;
 668 }
 669
 670 struct target_so_ops darwin_so_ops;
 671
 672 void _initialize_darwin_solib ();
 673 void
 674 _initialize_darwin_solib ()
 675 {
 676   darwin_so_ops.relocate_section_addresses = darwin_relocate_section_addresses;
 677   darwin_so_ops.free_so = darwin_free_so;
 678   darwin_so_ops.clear_solib = darwin_clear_solib;
 679   darwin_so_ops.solib_create_inferior_hook = darwin_solib_create_inferior_hook;
 680   darwin_so_ops.current_sos = darwin_current_sos;
 681   darwin_so_ops.open_symbol_file_object = open_symbol_file_object;
 682   darwin_so_ops.in_dynsym_resolve_code = darwin_in_dynsym_resolve_code;
 683   darwin_so_ops.bfd_open = darwin_bfd_open;
 684 }