gdb/solib-darwin.c

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