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   struct so_list *head = NULL;
 218   struct so_list *tail = NULL;
 219   int i;
 220
 221   /* Be sure image infos are loaded.  */
 222   darwin_load_image_infos ();
 223
 224   if (!darwin_dyld_version_ok ())
 225     return NULL;
 226
 227   image_info_size = ptr_len * 3;
 228
 229   /* Read infos for each solib.
 230      The first entry was rumored to be the executable itself, but this is not
 231      true when a large number of shared libraries are used (table expanded ?).
 232      We now check all entries, but discard executable images.  */
 233   for (i = 0; i < dyld_all_image.count; i++)
 234     {
 235       CORE_ADDR info = dyld_all_image.info + i * image_info_size;
 236       char buf[image_info_size];
 237       CORE_ADDR load_addr;
 238       CORE_ADDR path_addr;
 239       struct mach_o_header_external hdr;
 240       unsigned long hdr_val;
 241       char *file_path;
 242       int errcode;
 243       struct darwin_so_list *dnew;
 244       struct so_list *new;
 245       struct cleanup *old_chain;
 246
 247       /* Read image info from inferior.  */
 248       if (target_read_memory (info, buf, image_info_size))
 249         break;
 250
 251       load_addr = extract_typed_address (buf, ptr_type);
 252       path_addr = extract_typed_address (buf + ptr_len, ptr_type);
 253
 254       /* Read Mach-O header from memory.  */
 255       if (target_read_memory (load_addr, (char *) &hdr, sizeof (hdr) - 4))
 256         break;
 257       /* Discard wrong magic numbers.  Shouldn't happen.  */
 258       hdr_val = extract_unsigned_integer
 259         (hdr.magic, sizeof (hdr.magic), byte_order);
 260       if (hdr_val != BFD_MACH_O_MH_MAGIC && hdr_val != BFD_MACH_O_MH_MAGIC_64)
 261         continue;
 262       /* Discard executable.  Should happen only once.  */
 263       hdr_val = extract_unsigned_integer
 264         (hdr.filetype, sizeof (hdr.filetype), byte_order);
 265       if (hdr_val == BFD_MACH_O_MH_EXECUTE)
 266         continue;
 267
 268       target_read_string (path_addr, &file_path,
 269                           SO_NAME_MAX_PATH_SIZE - 1, &errcode);
 270       if (errcode)
 271         break;
 272
 273       /* Create and fill the new so_list element.  */
 274       dnew = XZALLOC (struct darwin_so_list);
 275       new = &dnew->sl;
 276       old_chain = make_cleanup (xfree, dnew);
 277
 278       new->lm_info = &dnew->li;
 279
 280       strncpy (new->so_name, file_path, SO_NAME_MAX_PATH_SIZE - 1);
 281       new->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
 282       strcpy (new->so_original_name, new->so_name);
 283       xfree (file_path);
 284       new->lm_info->lm_addr = load_addr;
 285
 286       if (head == NULL)
 287         head = new;
 288       else
 289         tail->next = new;
 290       tail = new;
 291
 292       discard_cleanups (old_chain);
 293     }
 294
 295   return head;
 296 }
 297
 298 /* Return 1 if PC lies in the dynamic symbol resolution code of the
 299    run time loader.  */
 300
 301 static int
 302 darwin_in_dynsym_resolve_code (CORE_ADDR pc)
 303 {
 304   return 0;
 305 }
 306
 307
 308 /* No special symbol handling.  */
 309
 310 static void
 311 darwin_special_symbol_handling (void)
 312 {
 313 }
 314
 315 /* Extract dyld_all_image_addr when the process was just created, assuming the
 316    current PC is at the entry of the dynamic linker.  */
 317
 318 static void
 319 darwin_solib_get_all_image_info_addr_at_init (void)
 320 {
 321   gdb_byte *interp_name;
 322   CORE_ADDR load_addr = 0;
 323   bfd *dyld_bfd = NULL;
 324
 325   /* This method doesn't work with an attached process.  */
 326   if (current_inferior ()->attach_flag)
 327     return;
 328
 329   /* Find the program interpreter.  */
 330   interp_name = find_program_interpreter ();
 331   if (!interp_name)
 332     return;
 333
 334   /* Create a bfd for the interpreter.  */
 335   dyld_bfd = bfd_openr (interp_name, gnutarget);
 336   if (dyld_bfd)
 337     {
 338       bfd *sub;
 339
 340       sub = bfd_mach_o_fat_extract (dyld_bfd, bfd_object,
 341                                     gdbarch_bfd_arch_info (target_gdbarch));
 342       if (sub)
 343         dyld_bfd = sub;
 344       else
 345         {
 346           bfd_close (dyld_bfd);
 347           dyld_bfd = NULL;
 348         }
 349     }
 350   if (!dyld_bfd)
 351     return;
 352
 353   /* We find the dynamic linker's base address by examining
 354      the current pc (which should point at the entry point for the
 355      dynamic linker) and subtracting the offset of the entry point.  */
 356   load_addr = (regcache_read_pc (get_current_regcache ())
 357                - bfd_get_start_address (dyld_bfd));
 358
 359   /* Now try to set a breakpoint in the dynamic linker.  */
 360   dyld_all_image_addr =
 361     lookup_symbol_from_bfd (dyld_bfd, "_dyld_all_image_infos");
 362
 363   bfd_close (dyld_bfd);
 364
 365   if (dyld_all_image_addr == 0)
 366     return;
 367
 368   dyld_all_image_addr += load_addr;
 369 }
 370
 371 /* Extract dyld_all_image_addr reading it from
 372    TARGET_OBJECT_DARWIN_DYLD_INFO.  */
 373
 374 static void
 375 darwin_solib_read_all_image_info_addr (void)
 376 {
 377   gdb_byte buf[8 + 8 + 4];
 378   LONGEST len;
 379   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
 380
 381   len = target_read (&current_target, TARGET_OBJECT_DARWIN_DYLD_INFO, NULL,
 382                      buf, 0, sizeof (buf));
 383   if (len != sizeof (buf))
 384     return;
 385
 386   dyld_all_image_addr = extract_unsigned_integer (buf, 8, byte_order);
 387 }
 388
 389 /* Shared library startup support.  See documentation in solib-svr4.c.  */
 390
 391 static void
 392 darwin_solib_create_inferior_hook (int from_tty)
 393 {
 394   dyld_all_image_addr = 0;
 395
 396   darwin_solib_read_all_image_info_addr ();
 397
 398   if (dyld_all_image_addr == 0)
 399     darwin_solib_get_all_image_info_addr_at_init ();
 400
 401   if (dyld_all_image_addr == 0)
 402     return;
 403
 404   darwin_load_image_infos ();
 405
 406   if (darwin_dyld_version_ok ())
 407     create_solib_event_breakpoint (target_gdbarch, dyld_all_image.notifier);
 408 }
 409
 410 static void
 411 darwin_clear_solib (void)
 412 {
 413   dyld_all_image_addr = 0;
 414   dyld_all_image.version = 0;
 415 }
 416
 417 static void
 418 darwin_free_so (struct so_list *so)
 419 {
 420 }
 421
 422 /* The section table is built from bfd sections using bfd VMAs.
 423    Relocate these VMAs according to solib info.  */
 424
 425 static void
 426 darwin_relocate_section_addresses (struct so_list *so,
 427                                    struct target_section *sec)
 428 {
 429   sec->addr += so->lm_info->lm_addr;
 430   sec->endaddr += so->lm_info->lm_addr;
 431
 432   /* Best effort to set addr_high/addr_low.  This is used only by
 433      'info sharedlibary'.  */
 434   if (so->addr_high == 0)
 435     {
 436       so->addr_low = sec->addr;
 437       so->addr_high = sec->endaddr;
 438     }
 439   if (sec->endaddr > so->addr_high)
 440     so->addr_high = sec->endaddr;
 441   if (sec->addr < so->addr_low)
 442     so->addr_low = sec->addr;
 443 }
 444 \f
 445 static struct symbol *
 446 darwin_lookup_lib_symbol (const struct objfile *objfile,
 447                           const char *name,
 448                           const domain_enum domain)
 449 {
 450   return NULL;
 451 }
 452
 453 static bfd *
 454 darwin_bfd_open (char *pathname)
 455 {
 456   char *found_pathname;
 457   int found_file;
 458   bfd *abfd;
 459   bfd *res;
 460
 461   /* Search for shared library file.  */
 462   found_pathname = solib_find (pathname, &found_file);
 463   if (found_pathname == NULL)
 464     perror_with_name (pathname);
 465
 466   /* Open bfd for shared library.  */
 467   abfd = solib_bfd_fopen (found_pathname, found_file);
 468
 469   res = bfd_mach_o_fat_extract (abfd, bfd_object,
 470                                 gdbarch_bfd_arch_info (target_gdbarch));
 471   if (!res)
 472     {
 473       bfd_close (abfd);
 474       make_cleanup (xfree, found_pathname);
 475       error (_("`%s': not a shared-library: %s"),
 476              found_pathname, bfd_errmsg (bfd_get_error ()));
 477     }
 478
 479   /* Make sure that the filename is malloc'ed.  The current filename
 480      for fat-binaries BFDs is a name that was generated by BFD, usually
 481      a static string containing the name of the architecture.  */
 482   res->filename = xstrdup (pathname);
 483
 484   return res;
 485 }
 486
 487 struct target_so_ops darwin_so_ops;
 488
 489 /* -Wmissing-prototypes */
 490 extern initialize_file_ftype _initialize_darwin_solib;
 491
 492 void
 493 _initialize_darwin_solib (void)
 494 {
 495   darwin_so_ops.relocate_section_addresses = darwin_relocate_section_addresses;
 496   darwin_so_ops.free_so = darwin_free_so;
 497   darwin_so_ops.clear_solib = darwin_clear_solib;
 498   darwin_so_ops.solib_create_inferior_hook = darwin_solib_create_inferior_hook;
 499   darwin_so_ops.special_symbol_handling = darwin_special_symbol_handling;
 500   darwin_so_ops.current_sos = darwin_current_sos;
 501   darwin_so_ops.open_symbol_file_object = open_symbol_file_object;
 502   darwin_so_ops.in_dynsym_resolve_code = darwin_in_dynsym_resolve_code;
 503   darwin_so_ops.lookup_lib_global_symbol = darwin_lookup_lib_symbol;
 504   darwin_so_ops.bfd_open = darwin_bfd_open;
 505 }