gdb/solib-darwin.c

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