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