gdb/solib-darwin.c

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