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