gdb/solib-darwin.c

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