gdb/solib-darwin.c

   1 /* Handle Darwin shared libraries for GDB, the GNU Debugger.
   2
   3    Copyright (C) 2009-2012 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
  32 #include "gdb_assert.h"
  33
  34 #include "solist.h"
  35 #include "solib.h"
  36 #include "solib-svr4.h"
  37
  38 #include "bfd-target.h"
  39 #include "elf-bfd.h"
  40 #include "exec.h"
  41 #include "auxv.h"
  42 #include "exceptions.h"
  43 #include "mach-o.h"
  44 #include "mach-o/external.h"
  45
  46 struct gdb_dyld_image_info
  47 {
  48   /* Base address (which corresponds to the Mach-O header).  */
  49   CORE_ADDR mach_header;
  50   /* Image file path.  */
  51   CORE_ADDR file_path;
  52   /* st.m_time of image file.  */
  53   unsigned long mtime;
  54 };
  55
  56 /* Content of inferior dyld_all_image_infos structure.
  57    See /usr/include/mach-o/dyld_images.h for the documentation.  */
  58 struct gdb_dyld_all_image_infos
  59 {
  60   /* Version (1).  */
  61   unsigned int version;
  62   /* Number of images.  */
  63   unsigned int count;
  64   /* Image description.  */
  65   CORE_ADDR info;
  66   /* Notifier (function called when a library is added or removed).  */
  67   CORE_ADDR notifier;
  68 };
  69
  70 /* Current all_image_infos version.  */
  71 #define DYLD_VERSION_MIN 1
  72 #define DYLD_VERSION_MAX 12
  73
  74 /* Address of structure dyld_all_image_infos in inferior.  */
  75 static CORE_ADDR dyld_all_image_addr;
  76
  77 /* Gdb copy of dyld_all_info_infos.  */
  78 static struct gdb_dyld_all_image_infos dyld_all_image;
  79
  80 /* Return non-zero if the version in dyld_all_image is known.  */
  81
  82 static int
  83 darwin_dyld_version_ok (void)
  84 {
  85   return dyld_all_image.version >= DYLD_VERSION_MIN
  86     && dyld_all_image.version <= DYLD_VERSION_MAX;
  87 }
  88
  89 /* Read dyld_all_image from inferior.  */
  90
  91 static void
  92 darwin_load_image_infos (void)
  93 {
  94   gdb_byte buf[24];
  95   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
  96   struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
  97   int len;
  98
  99   /* If the structure address is not known, don't continue.  */
 100   if (dyld_all_image_addr == 0)
 101     return;
 102
 103   /* The structure has 4 fields: version (4 bytes), count (4 bytes),
 104      info (pointer) and notifier (pointer).  */
 105   len = 4 + 4 + 2 * ptr_type->length;
 106   gdb_assert (len <= sizeof (buf));
 107   memset (&dyld_all_image, 0, sizeof (dyld_all_image));
 108
 109   /* Read structure raw bytes from target.  */
 110   if (target_read_memory (dyld_all_image_addr, buf, len))
 111     return;
 112
 113   /* Extract the fields.  */
 114   dyld_all_image.version = extract_unsigned_integer (buf, 4, byte_order);
 115   if (!darwin_dyld_version_ok ())
 116     return;
 117
 118   dyld_all_image.count = extract_unsigned_integer (buf + 4, 4, byte_order);
 119   dyld_all_image.info = extract_typed_address (buf + 8, ptr_type);
 120   dyld_all_image.notifier = extract_typed_address
 121     (buf + 8 + ptr_type->length, ptr_type);
 122 }
 123
 124 /* Link map info to include in an allocated so_list entry.  */
 125
 126 struct lm_info
 127 {
 128   /* The target location of lm.  */
 129   CORE_ADDR lm_addr;
 130 };
 131
 132 struct darwin_so_list
 133 {
 134   /* Common field.  */
 135   struct so_list sl;
 136   /* Darwin specific data.  */
 137   struct lm_info li;
 138 };
 139
 140 /* Lookup the value for a specific symbol.  */
 141
 142 static CORE_ADDR
 143 lookup_symbol_from_bfd (bfd *abfd, char *symname)
 144 {
 145   long storage_needed;
 146   asymbol **symbol_table;
 147   unsigned int number_of_symbols;
 148   unsigned int i;
 149   CORE_ADDR symaddr = 0;
 150
 151   storage_needed = bfd_get_symtab_upper_bound (abfd);
 152
 153   if (storage_needed <= 0)
 154     return 0;
 155
 156   symbol_table = (asymbol **) xmalloc (storage_needed);
 157   number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
 158
 159   for (i = 0; i < number_of_symbols; i++)
 160     {
 161       asymbol *sym = symbol_table[i];
 162
 163       if (strcmp (sym->name, symname) == 0
 164           && (sym->section->flags & (SEC_CODE | SEC_DATA)) != 0)
 165         {
 166           /* BFD symbols are section relative.  */
 167           symaddr = sym->value + sym->section->vma;
 168           break;
 169         }
 170     }
 171   xfree (symbol_table);
 172
 173   return symaddr;
 174 }
 175
 176 /* Return program interpreter string.  */
 177
 178 static gdb_byte *
 179 find_program_interpreter (void)
 180 {
 181   gdb_byte *buf = NULL;
 182
 183   /* If we have an exec_bfd, get the interpreter from the load commands.  */
 184   if (exec_bfd)
 185     {
 186       bfd_mach_o_load_command *cmd;
 187
 188       if (bfd_mach_o_lookup_command (exec_bfd,
 189                                      BFD_MACH_O_LC_LOAD_DYLINKER, &cmd) == 1)
 190         return cmd->command.dylinker.name_str;
 191     }
 192
 193   /* If we didn't find it, read from memory.
 194      FIXME: todo.  */
 195   return buf;
 196 }
 197
 198 /*  Not used.  I don't see how the main symbol file can be found: the
 199     interpreter name is needed and it is known from the executable file.
 200     Note that darwin-nat.c implements pid_to_exec_file.  */
 201
 202 static int
 203 open_symbol_file_object (void *from_ttyp)
 204 {
 205   return 0;
 206 }
 207
 208 /* Build a list of currently loaded shared objects.  See solib-svr4.c.  */
 209
 210 static struct so_list *
 211 darwin_current_sos (void)
 212 {
 213   struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
 214   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
 215   int ptr_len = TYPE_LENGTH (ptr_type);
 216   unsigned int image_info_size;
 217   CORE_ADDR lm;
 218   struct so_list *head = NULL;
 219   struct so_list *tail = NULL;
 220   int i;
 221
 222   /* Be sure image infos are loaded.  */
 223   darwin_load_image_infos ();
 224
 225   if (!darwin_dyld_version_ok ())
 226     return NULL;
 227
 228   image_info_size = ptr_len * 3;
 229
 230   /* Read infos for each solib.
 231      The first entry was rumored to be the executable itself, but this is not
 232      true when a large number of shared libraries are used (table expanded ?).
 233      We now check all entries, but discard executable images.  */
 234   for (i = 0; i < dyld_all_image.count; i++)
 235     {
 236       CORE_ADDR info = dyld_all_image.info + i * image_info_size;
 237       char buf[image_info_size];
 238       CORE_ADDR load_addr;
 239       CORE_ADDR path_addr;
 240       struct mach_o_header_external hdr;
 241       unsigned long hdr_val;
 242       char *file_path;
 243       int errcode;
 244       struct darwin_so_list *dnew;
 245       struct so_list *new;
 246       struct cleanup *old_chain;
 247
 248       /* Read image info from inferior.  */
 249       if (target_read_memory (info, buf, image_info_size))
 250         break;
 251
 252       load_addr = extract_typed_address (buf, ptr_type);
 253       path_addr = extract_typed_address (buf + ptr_len, ptr_type);
 254
 255       /* Read Mach-O header from memory.  */
 256       if (target_read_memory (load_addr, (char *) &hdr, sizeof (hdr) - 4))
 257         break;
 258       /* Discard wrong magic numbers.  Shouldn't happen.  */
 259       hdr_val = extract_unsigned_integer
 260         (hdr.magic, sizeof (hdr.magic), byte_order);
 261       if (hdr_val != BFD_MACH_O_MH_MAGIC && hdr_val != BFD_MACH_O_MH_MAGIC_64)
 262         continue;
 263       /* Discard executable.  Should happen only once.  */
 264       hdr_val = extract_unsigned_integer
 265         (hdr.filetype, sizeof (hdr.filetype), byte_order);
 266       if (hdr_val == BFD_MACH_O_MH_EXECUTE)
 267         continue;
 268
 269       target_read_string (path_addr, &file_path,
 270                           SO_NAME_MAX_PATH_SIZE - 1, &errcode);
 271       if (errcode)
 272         break;
 273
 274       /* Create and fill the new so_list element.  */
 275       dnew = XZALLOC (struct darwin_so_list);
 276       new = &dnew->sl;
 277       old_chain = make_cleanup (xfree, dnew);
 278
 279       new->lm_info = &dnew->li;
 280
 281       strncpy (new->so_name, file_path, SO_NAME_MAX_PATH_SIZE - 1);
 282       new->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
 283       strcpy (new->so_original_name, new->so_name);
 284       xfree (file_path);
 285       new->lm_info->lm_addr = load_addr;
 286
 287       if (head == NULL)
 288         head = new;
 289       else
 290         tail->next = new;
 291       tail = new;
 292
 293       discard_cleanups (old_chain);
 294     }
 295
 296   return head;
 297 }
 298
 299 /* Return 1 if PC lies in the dynamic symbol resolution code of the
 300    run time loader.  */
 301
 302 static int
 303 darwin_in_dynsym_resolve_code (CORE_ADDR pc)
 304 {
 305   return 0;
 306 }
 307
 308
 309 /* No special symbol handling.  */
 310
 311 static void
 312 darwin_special_symbol_handling (void)
 313 {
 314 }
 315
 316 /* Extract dyld_all_image_addr when the process was just created, assuming the
 317    current PC is at the entry of the dynamic linker.  */
 318
 319 static void
 320 darwin_solib_get_all_image_info_addr_at_init (void)
 321 {
 322   gdb_byte *interp_name;
 323   CORE_ADDR load_addr = 0;
 324   bfd *dyld_bfd = NULL;
 325
 326   /* This method doesn't work with an attached process.  */
 327   if (current_inferior ()->attach_flag)
 328     return;
 329
 330   /* Find the program interpreter.  */
 331   interp_name = find_program_interpreter ();
 332   if (!interp_name)
 333     return;
 334
 335   /* Create a bfd for the interpreter.  */
 336   dyld_bfd = bfd_openr (interp_name, gnutarget);
 337   if (dyld_bfd)
 338     {
 339       bfd *sub;
 340
 341       sub = bfd_mach_o_fat_extract (dyld_bfd, bfd_object,
 342                                     gdbarch_bfd_arch_info (target_gdbarch));
 343       if (sub)
 344         dyld_bfd = sub;
 345       else
 346         {
 347           bfd_close (dyld_bfd);
 348           dyld_bfd = NULL;
 349         }
 350     }
 351   if (!dyld_bfd)
 352     return;
 353
 354   /* We find the dynamic linker's base address by examining
 355      the current pc (which should point at the entry point for the
 356      dynamic linker) and subtracting the offset of the entry point.  */
 357   load_addr = (regcache_read_pc (get_current_regcache ())
 358                - bfd_get_start_address (dyld_bfd));
 359
 360   /* Now try to set a breakpoint in the dynamic linker.  */
 361   dyld_all_image_addr =
 362     lookup_symbol_from_bfd (dyld_bfd, "_dyld_all_image_infos");
 363
 364   bfd_close (dyld_bfd);
 365
 366   if (dyld_all_image_addr == 0)
 367     return;
 368
 369   dyld_all_image_addr += load_addr;
 370 }
 371
 372 /* Extract dyld_all_image_addr reading it from
 373    TARGET_OBJECT_DARWIN_DYLD_INFO.  */
 374
 375 static void
 376 darwin_solib_read_all_image_info_addr (void)
 377 {
 378   gdb_byte buf[8 + 8 + 4];
 379   LONGEST len;
 380   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
 381
 382   len = target_read (&current_target, TARGET_OBJECT_DARWIN_DYLD_INFO, NULL,
 383                      buf, 0, sizeof (buf));
 384   if (len != sizeof (buf))
 385     return;
 386
 387   dyld_all_image_addr = extract_unsigned_integer (buf, 8, byte_order);
 388 }
 389
 390 /* Shared library startup support.  See documentation in solib-svr4.c.  */
 391
 392 static void
 393 darwin_solib_create_inferior_hook (int from_tty)
 394 {
 395   dyld_all_image_addr = 0;
 396
 397   darwin_solib_read_all_image_info_addr ();
 398
 399   if (dyld_all_image_addr == 0)
 400     darwin_solib_get_all_image_info_addr_at_init ();
 401
 402   if (dyld_all_image_addr == 0)
 403     return;
 404
 405   darwin_load_image_infos ();
 406
 407   if (darwin_dyld_version_ok ())
 408     create_solib_event_breakpoint (target_gdbarch, dyld_all_image.notifier);
 409 }
 410
 411 static void
 412 darwin_clear_solib (void)
 413 {
 414   dyld_all_image_addr = 0;
 415   dyld_all_image.version = 0;
 416 }
 417
 418 static void
 419 darwin_free_so (struct so_list *so)
 420 {
 421 }
 422
 423 /* The section table is built from bfd sections using bfd VMAs.
 424    Relocate these VMAs according to solib info.  */
 425
 426 static void
 427 darwin_relocate_section_addresses (struct so_list *so,
 428                                    struct target_section *sec)
 429 {
 430   sec->addr += so->lm_info->lm_addr;
 431   sec->endaddr += so->lm_info->lm_addr;
 432
 433   /* Best effort to set addr_high/addr_low.  This is used only by
 434      'info sharedlibary'.  */
 435   if (so->addr_high == 0)
 436     {
 437       so->addr_low = sec->addr;
 438       so->addr_high = sec->endaddr;
 439     }
 440   if (sec->endaddr > so->addr_high)
 441     so->addr_high = sec->endaddr;
 442   if (sec->addr < so->addr_low)
 443     so->addr_low = sec->addr;
 444 }
 445 \f
 446 static struct symbol *
 447 darwin_lookup_lib_symbol (const struct objfile *objfile,
 448                           const char *name,
 449                           const domain_enum domain)
 450 {
 451   return NULL;
 452 }
 453
 454 static bfd *
 455 darwin_bfd_open (char *pathname)
 456 {
 457   char *found_pathname;
 458   int found_file;
 459   bfd *abfd;
 460   bfd *res;
 461
 462   /* Search for shared library file.  */
 463   found_pathname = solib_find (pathname, &found_file);
 464   if (found_pathname == NULL)
 465     perror_with_name (pathname);
 466
 467   /* Open bfd for shared library.  */
 468   abfd = solib_bfd_fopen (found_pathname, found_file);
 469
 470   res = bfd_mach_o_fat_extract (abfd, bfd_object,
 471                                 gdbarch_bfd_arch_info (target_gdbarch));
 472   if (!res)
 473     {
 474       bfd_close (abfd);
 475       make_cleanup (xfree, found_pathname);
 476       error (_("`%s': not a shared-library: %s"),
 477              found_pathname, bfd_errmsg (bfd_get_error ()));
 478     }
 479
 480   /* Make sure that the filename is malloc'ed.  The current filename
 481      for fat-binaries BFDs is a name that was generated by BFD, usually
 482      a static string containing the name of the architecture.  */
 483   res->filename = xstrdup (pathname);
 484
 485   return res;
 486 }
 487
 488 struct target_so_ops darwin_so_ops;
 489
 490 /* -Wmissing-prototypes */
 491 extern initialize_file_ftype _initialize_darwin_solib;
 492
 493 void
 494 _initialize_darwin_solib (void)
 495 {
 496   darwin_so_ops.relocate_section_addresses = darwin_relocate_section_addresses;
 497   darwin_so_ops.free_so = darwin_free_so;
 498   darwin_so_ops.clear_solib = darwin_clear_solib;
 499   darwin_so_ops.solib_create_inferior_hook = darwin_solib_create_inferior_hook;
 500   darwin_so_ops.special_symbol_handling = darwin_special_symbol_handling;
 501   darwin_so_ops.current_sos = darwin_current_sos;
 502   darwin_so_ops.open_symbol_file_object = open_symbol_file_object;
 503   darwin_so_ops.in_dynsym_resolve_code = darwin_in_dynsym_resolve_code;
 504   darwin_so_ops.lookup_lib_global_symbol = darwin_lookup_lib_symbol;
 505   darwin_so_ops.bfd_open = darwin_bfd_open;
 506 }