gdb/solib-darwin.c

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