gdb/solib-darwin.c

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