gdb/solib-darwin.c - gdb

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  1. /* Handle Darwin shared libraries for GDB, the GNU Debugger.

  3.    Copyright (C) 2009-2015 Free Software Foundation, Inc.

  5.    This file is part of GDB.

  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.

  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.

  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/>.  */

  20. #include "defs.h"

  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"

  33. #include "solist.h"
  34. #include "solib.h"
  35. #include "solib-svr4.h"

  37. #include "bfd-target.h"
  38. #include "elf-bfd.h"
  39. #include "exec.h"
  40. #include "auxv.h"
  41. #include "mach-o.h"
  42. #include "mach-o/external.h"

  44. ‌struct gdb_dyld_image_info
  45. {
  46.   /* Base address (which corresponds to the Mach-O header).  */
  47.   CORE_ADDR mach_header;
  48.   /* Image file path.  */
  49.   CORE_ADDR file_path;
  50.   /* st.m_time of image file.  */
  51.   unsigned long mtime;
  52. };

  54. /* Content of inferior dyld_all_image_infos structure.
  55.    See /usr/include/mach-o/dyld_images.h for the documentation.  */
  56. ‌struct gdb_dyld_all_image_infos
  57. {
  58.   /* Version (1).  */
  59.   unsigned int version;
  60.   /* Number of images.  */
  61.   unsigned int count;
  62.   /* Image description.  */
  63.   CORE_ADDR info;
  64.   /* Notifier (function called when a library is added or removed).  */
  65.   CORE_ADDR notifier;
  66. };

  68. /* Current all_image_infos version.  */
  69. ‌#define DYLD_VERSION_MIN 1
  70. ‌#define DYLD_VERSION_MAX 14

  72. /* Per PSPACE specific data.  */
  73. ‌struct darwin_info
  74. {
  75.   /* Address of structure dyld_all_image_infos in inferior.  */
  76.   CORE_ADDR all_image_addr;

  78.   /* Gdb copy of dyld_all_info_infos.  */
  79.   struct gdb_dyld_all_image_infos all_image;
  80. };

  82. /* Per-program-space data key.  */
  83. ‌static const struct program_space_data *solib_darwin_pspace_data;

  85. static void
  86. ‌darwin_pspace_data_cleanup (struct program_space *pspace, void *arg)
  87. {
  88.   xfree (arg);
  89. }

  91. /* Get the current darwin data.  If none is found yet, add it now.  This
  92.    function always returns a valid object.  */

  94. static struct darwin_info *
  95. ‌get_darwin_info (void)
  96. {
  97.   struct darwin_info *info;

  99.   info = program_space_data (current_program_space, solib_darwin_pspace_data);
  100.   if (info != NULL)
  101.     return info;

  103.   info = XCNEW (struct darwin_info);
  104.   set_program_space_data (current_program_space,
  105.                           solib_darwin_pspace_data, info);
  106.   return info;
  107. }

  109. /* Return non-zero if the version in dyld_all_image is known.  */

  111. static int
  112. ‌darwin_dyld_version_ok (const struct darwin_info *info)
  113. {
  114.   return info->all_image.version >= DYLD_VERSION_MIN
  115.     && info->all_image.version <= DYLD_VERSION_MAX;
  116. }

  118. /* Read dyld_all_image from inferior.  */

  120. static void
  121. ‌darwin_load_image_infos (struct darwin_info *info)
  122. {
  123.   gdb_byte buf[24];
  124.   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
  125.   struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
  126.   int len;

  128.   /* If the structure address is not known, don't continue.  */
  129.   if (info->all_image_addr == 0)
  130.     return;

  132.   /* The structure has 4 fields: version (4 bytes), count (4 bytes),
  133.      info (pointer) and notifier (pointer).  */
  134.   len = 4 + 4 + 2 * ptr_type->length;
  135.   gdb_assert (len <= sizeof (buf));
  136.   memset (&info->all_image, 0, sizeof (info->all_image));

  138.   /* Read structure raw bytes from target.  */
  139.   if (target_read_memory (info->all_image_addr, buf, len))
  140.     return;

  142.   /* Extract the fields.  */
  143.   info->all_image.version = extract_unsigned_integer (buf, 4, byte_order);
  144.   if (!darwin_dyld_version_ok (info))
  145.     return;

  147.   info->all_image.count = extract_unsigned_integer (buf + 4, 4, byte_order);
  148.   info->all_image.info = extract_typed_address (buf + 8, ptr_type);
  149.   info->all_image.notifier = extract_typed_address
  150.     (buf + 8 + ptr_type->length, ptr_type);
  151. }

  153. /* Link map info to include in an allocated so_list entry.  */

  155. ‌struct lm_info
  156. {
  157.   /* The target location of lm.  */
  158.   CORE_ADDR lm_addr;
  159. };

  161. ‌struct darwin_so_list
  162. {
  163.   /* Common field.  */
  164.   struct so_list sl;
  165.   /* Darwin specific data.  */
  166.   struct lm_info li;
  167. };

  169. /* Lookup the value for a specific symbol.  */

  171. static CORE_ADDR
  172. ‌lookup_symbol_from_bfd (bfd *abfd, char *symname)
  173. {
  174.   long storage_needed;
  175.   asymbol **symbol_table;
  176.   unsigned int number_of_symbols;
  177.   unsigned int i;
  178.   CORE_ADDR symaddr = 0;

  180.   storage_needed = bfd_get_symtab_upper_bound (abfd);

  182.   if (storage_needed <= 0)
  183.     return 0;

  185.   symbol_table = (asymbol **) xmalloc (storage_needed);
  186.   number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);

  188.   for (i = 0; i < number_of_symbols; i++)
  189.     {
  190.       asymbol *sym = symbol_table[i];

  192.       if (strcmp (sym->name, symname) == 0
  193.           && (sym->section->flags & (SEC_CODE | SEC_DATA)) != 0)
  194.         {
  195.           /* BFD symbols are section relative.  */
  196.           symaddr = sym->value + sym->section->vma;
  197.           break;
  198.         }
  199.     }
  200.   xfree (symbol_table);

  202.   return symaddr;
  203. }

  205. /* Return program interpreter string.  */

  207. static char *
  208. ‌find_program_interpreter (void)
  209. {
  210.   char *buf = NULL;

  212.   /* If we have an exec_bfd, get the interpreter from the load commands.  */
  213.   if (exec_bfd)
  214.     {
  215.       bfd_mach_o_load_command *cmd;

  217.       if (bfd_mach_o_lookup_command (exec_bfd,
  218.                                      BFD_MACH_O_LC_LOAD_DYLINKER, &cmd) == 1)
  219.         return cmd->command.dylinker.name_str;
  220.     }

  222.   /* If we didn't find it, read from memory.
  223.      FIXME: todo.  */
  224.   return buf;
  225. }

  227. /*  Not used.  I don't see how the main symbol file can be found: the
  228.     interpreter name is needed and it is known from the executable file.
  229.     Note that darwin-nat.c implements pid_to_exec_file.  */

  231. static int
  232. ‌open_symbol_file_object (void *from_ttyp)
  233. {
  234.   return 0;
  235. }

  237. /* Build a list of currently loaded shared objects.  See solib-svr4.c.  */

  239. static struct so_list *
  240. ‌darwin_current_sos (void)
  241. {
  242.   struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
  243.   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
  244.   int ptr_len = TYPE_LENGTH (ptr_type);
  245.   unsigned int image_info_size;
  246.   struct so_list *head = NULL;
  247.   struct so_list *tail = NULL;
  248.   int i;
  249.   struct darwin_info *info = get_darwin_info ();

  251.   /* Be sure image infos are loaded.  */
  252.   darwin_load_image_infos (info);

  254.   if (!darwin_dyld_version_ok (info))
  255.     return NULL;

  257.   image_info_size = ptr_len * 3;

  259.   /* Read infos for each solib.
  260.      The first entry was rumored to be the executable itself, but this is not
  261.      true when a large number of shared libraries are used (table expanded ?).
  262.      We now check all entries, but discard executable images.  */
  263.   for (i = 0; i < info->all_image.count; i++)
  264.     {
  265.       CORE_ADDR iinfo = info->all_image.info + i * image_info_size;
  266.       gdb_byte buf[image_info_size];
  267.       CORE_ADDR load_addr;
  268.       CORE_ADDR path_addr;
  269.       struct mach_o_header_external hdr;
  270.       unsigned long hdr_val;
  271.       char *file_path;
  272.       int errcode;
  273.       struct darwin_so_list *dnew;
  274.       struct so_list *new;
  275.       struct cleanup *old_chain;

  277.       /* Read image info from inferior.  */
  278.       if (target_read_memory (iinfo, buf, image_info_size))
  279.         break;

  281.       load_addr = extract_typed_address (buf, ptr_type);
  282.       path_addr = extract_typed_address (buf + ptr_len, ptr_type);

  284.       /* Read Mach-O header from memory.  */
  285.       if (target_read_memory (load_addr, (gdb_byte *) &hdr, sizeof (hdr) - 4))
  286.         break;
  287.       /* Discard wrong magic numbers.  Shouldn't happen.  */
  288.       hdr_val = extract_unsigned_integer
  289.         (hdr.magic, sizeof (hdr.magic), byte_order);
  290.       if (hdr_val != BFD_MACH_O_MH_MAGIC && hdr_val != BFD_MACH_O_MH_MAGIC_64)
  291.         continue;
  292.       /* Discard executable.  Should happen only once.  */
  293.       hdr_val = extract_unsigned_integer
  294.         (hdr.filetype, sizeof (hdr.filetype), byte_order);
  295.       if (hdr_val == BFD_MACH_O_MH_EXECUTE)
  296.         continue;

  298.       target_read_string (path_addr, &file_path,
  299.                           SO_NAME_MAX_PATH_SIZE - 1, &errcode);
  300.       if (errcode)
  301.         break;

  303.       /* Create and fill the new so_list element.  */
  304.       dnew = XCNEW (struct darwin_so_list);
  305.       new = &dnew->sl;
  306.       old_chain = make_cleanup (xfree, dnew);

  308.       new->lm_info = &dnew->li;

  310.       strncpy (new->so_name, file_path, SO_NAME_MAX_PATH_SIZE - 1);
  311.       new->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
  312.       strcpy (new->so_original_name, new->so_name);
  313.       xfree (file_path);
  314.       new->lm_info->lm_addr = load_addr;

  316.       if (head == NULL)
  317.         head = new;
  318.       else
  319.         tail->next = new;
  320.       tail = new;

  322.       discard_cleanups (old_chain);
  323.     }

  325.   return head;
  326. }

  328. /* Get the load address of the executable.  We assume that the dyld info are
  329.    correct.  */

  331. static CORE_ADDR
  332. ‌darwin_read_exec_load_addr (struct darwin_info *info)
  333. {
  334.   struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
  335.   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
  336.   int ptr_len = TYPE_LENGTH (ptr_type);
  337.   unsigned int image_info_size = ptr_len * 3;
  338.   int i;

  340.   /* Read infos for each solib.  One of them should be the executable.  */
  341.   for (i = 0; i < info->all_image.count; i++)
  342.     {
  343.       CORE_ADDR iinfo = info->all_image.info + i * image_info_size;
  344.       gdb_byte buf[image_info_size];
  345.       CORE_ADDR load_addr;
  346.       struct mach_o_header_external hdr;
  347.       unsigned long hdr_val;

  349.       /* Read image info from inferior.  */
  350.       if (target_read_memory (iinfo, buf, image_info_size))
  351.         break;

  353.       load_addr = extract_typed_address (buf, ptr_type);

  355.       /* Read Mach-O header from memory.  */
  356.       if (target_read_memory (load_addr, (gdb_byte *) &hdr, sizeof (hdr) - 4))
  357.         break;
  358.       /* Discard wrong magic numbers.  Shouldn't happen.  */
  359.       hdr_val = extract_unsigned_integer
  360.         (hdr.magic, sizeof (hdr.magic), byte_order);
  361.       if (hdr_val != BFD_MACH_O_MH_MAGIC && hdr_val != BFD_MACH_O_MH_MAGIC_64)
  362.         continue;
  363.       /* Check executable.  */
  364.       hdr_val = extract_unsigned_integer
  365.         (hdr.filetype, sizeof (hdr.filetype), byte_order);
  366.       if (hdr_val == BFD_MACH_O_MH_EXECUTE)
  367.         return load_addr;
  368.     }

  370.   return 0;
  371. }

  373. /* Return 1 if PC lies in the dynamic symbol resolution code of the
  374.    run time loader.  */

  376. static int
  377. ‌darwin_in_dynsym_resolve_code (CORE_ADDR pc)
  378. {
  379.   return 0;
  380. }


  383. /* No special symbol handling.  */

  385. static void
  386. ‌darwin_special_symbol_handling (void)
  387. {
  388. }

  390. /* A wrapper for bfd_mach_o_fat_extract that handles reference
  391.    counting properly.  This will either return NULL, or return a new
  392.    reference to a BFD.  */

  394. static bfd *
  395. ‌gdb_bfd_mach_o_fat_extract (bfd *abfd, bfd_format format,
  396.                             const bfd_arch_info_type *arch)
  397. {
  398.   bfd *result = bfd_mach_o_fat_extract (abfd, format, arch);

  400.   if (result == NULL)
  401.     return NULL;

  403.   if (result == abfd)
  404.     gdb_bfd_ref (result);
  405.   else
  406.     gdb_bfd_mark_parent (result, abfd);

  408.   return result;
  409. }

  411. /* Extract dyld_all_image_addr when the process was just created, assuming the
  412.    current PC is at the entry of the dynamic linker.  */

  414. static void
  415. ‌darwin_solib_get_all_image_info_addr_at_init (struct darwin_info *info)
  416. {
  417.   char *interp_name;
  418.   CORE_ADDR load_addr = 0;
  419.   bfd *dyld_bfd = NULL;
  420.   struct cleanup *cleanup;

  422.   /* This method doesn't work with an attached process.  */
  423.   if (current_inferior ()->attach_flag)
  424.     return;

  426.   /* Find the program interpreter.  */
  427.   interp_name = find_program_interpreter ();
  428.   if (!interp_name)
  429.     return;

  431.   cleanup = make_cleanup (null_cleanup, NULL);

  433.   /* Create a bfd for the interpreter.  */
  434.   dyld_bfd = gdb_bfd_open (interp_name, gnutarget, -1);
  435.   if (dyld_bfd)
  436.     {
  437.       bfd *sub;

  439.       make_cleanup_bfd_unref (dyld_bfd);
  440.       sub = gdb_bfd_mach_o_fat_extract (dyld_bfd, bfd_object,
  441.                                         gdbarch_bfd_arch_info (target_gdbarch ()));
  442.       if (sub)
  443.         {
  444.           dyld_bfd = sub;
  445.           make_cleanup_bfd_unref (sub);
  446.         }
  447.       else
  448.         dyld_bfd = NULL;
  449.     }
  450.   if (!dyld_bfd)
  451.     {
  452.       do_cleanups (cleanup);
  453.       return;
  454.     }

  456.   /* We find the dynamic linker's base address by examining
  457.      the current pc (which should point at the entry point for the
  458.      dynamic linker) and subtracting the offset of the entry point.  */
  459.   load_addr = (regcache_read_pc (get_current_regcache ())
  460.                - bfd_get_start_address (dyld_bfd));

  462.   /* Now try to set a breakpoint in the dynamic linker.  */
  463.   info->all_image_addr =
  464.     lookup_symbol_from_bfd (dyld_bfd, "_dyld_all_image_infos");

  466.   do_cleanups (cleanup);

  468.   if (info->all_image_addr == 0)
  469.     return;

  471.   info->all_image_addr += load_addr;
  472. }

  474. /* Extract dyld_all_image_addr reading it from
  475.    TARGET_OBJECT_DARWIN_DYLD_INFO.  */

  477. static void
  478. ‌darwin_solib_read_all_image_info_addr (struct darwin_info *info)
  479. {
  480.   gdb_byte buf[8 + 8 + 4];
  481.   LONGEST len;
  482.   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());

  484.   len = target_read (&current_target, TARGET_OBJECT_DARWIN_DYLD_INFO, NULL,
  485.                      buf, 0, sizeof (buf));
  486.   if (len != sizeof (buf))
  487.     return;

  489.   info->all_image_addr = extract_unsigned_integer (buf, 8, byte_order);
  490. }

  492. /* Shared library startup support.  See documentation in solib-svr4.c.  */

  494. static void
  495. ‌darwin_solib_create_inferior_hook (int from_tty)
  496. {
  497.   struct darwin_info *info = get_darwin_info ();
  498.   CORE_ADDR load_addr;

  500.   info->all_image_addr = 0;

  502.   darwin_solib_read_all_image_info_addr (info);

  504.   if (info->all_image_addr == 0)
  505.     darwin_solib_get_all_image_info_addr_at_init (info);

  507.   if (info->all_image_addr == 0)
  508.     return;

  510.   darwin_load_image_infos (info);

  512.   if (!darwin_dyld_version_ok (info))
  513.     {
  514.       warning (_("unhandled dyld version (%d)"), info->all_image.version);
  515.       return;
  516.     }

  518.   create_solib_event_breakpoint (target_gdbarch (), info->all_image.notifier);

  520.   /* Possible relocate the main executable (PIE).  */
  521.   load_addr = darwin_read_exec_load_addr (info);
  522.   if (load_addr != 0 && symfile_objfile != NULL)
  523.     {
  524.       CORE_ADDR vmaddr;

  526.       /* Find the base address of the executable.  */
  527.       vmaddr = bfd_mach_o_get_base_address (exec_bfd);

  529.       /* Relocate.  */
  530.       if (vmaddr != load_addr)
  531.         objfile_rebase (symfile_objfile, load_addr - vmaddr);
  532.     }
  533. }

  535. static void
  536. ‌darwin_clear_solib (void)
  537. {
  538.   struct darwin_info *info = get_darwin_info ();

  540.   info->all_image_addr = 0;
  541.   info->all_image.version = 0;
  542. }

  544. static void
  545. ‌darwin_free_so (struct so_list *so)
  546. {
  547. }

  549. /* The section table is built from bfd sections using bfd VMAs.
  550.    Relocate these VMAs according to solib info.  */

  552. static void
  553. ‌darwin_relocate_section_addresses (struct so_list *so,
  554.                                    struct target_section *sec)
  555. {
  556.   sec->addr += so->lm_info->lm_addr;
  557.   sec->endaddr += so->lm_info->lm_addr;

  559.   /* Best effort to set addr_high/addr_low.  This is used only by
  560.      'info sharedlibary'.  */
  561.   if (so->addr_high == 0)
  562.     {
  563.       so->addr_low = sec->addr;
  564.       so->addr_high = sec->endaddr;
  565.     }
  566.   if (sec->endaddr > so->addr_high)
  567.     so->addr_high = sec->endaddr;
  568.   if (sec->addr < so->addr_low)
  569.     so->addr_low = sec->addr;
  570. }

  572. static struct symbol *
  573. ‌darwin_lookup_lib_symbol (struct objfile *objfile,
  574.                           const char *name,
  575.                           const domain_enum domain)
  576. {
  577.   return NULL;
  578. }

  580. static bfd *
  581. ‌darwin_bfd_open (char *pathname)
  582. {
  583.   char *found_pathname;
  584.   int found_file;
  585.   bfd *abfd;
  586.   bfd *res;

  588.   /* Search for shared library file.  */
  589.   found_pathname = solib_find (pathname, &found_file);
  590.   if (found_pathname == NULL)
  591.     perror_with_name (pathname);

  593.   /* Open bfd for shared library.  */
  594.   abfd = solib_bfd_fopen (found_pathname, found_file);

  596.   res = gdb_bfd_mach_o_fat_extract (abfd, bfd_object,
  597.                                     gdbarch_bfd_arch_info (target_gdbarch ()));
  598.   if (!res)
  599.     {
  600.       make_cleanup_bfd_unref (abfd);
  601.       error (_("`%s': not a shared-library: %s"),
  602.              bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
  603.     }

  605.   /* The current filename for fat-binary BFDs is a name generated
  606.      by BFD, usually a string containing the name of the architecture.
  607.      Reset its value to the actual filename.  */
  608.   xfree (bfd_get_filename (res));
  609.   res->filename = xstrdup (pathname);

  611.   gdb_bfd_unref (abfd);
  612.   return res;
  613. }

  615. ‌struct target_so_ops darwin_so_ops;

  617. /* -Wmissing-prototypes */
  618. extern initialize_file_ftype _initialize_darwin_solib;

  620. void
  621. ‌_initialize_darwin_solib (void)
  622. {
  623.   solib_darwin_pspace_data
  624.     = register_program_space_data_with_cleanup (NULL,
  625.                                                 darwin_pspace_data_cleanup);

  627.   darwin_so_ops.relocate_section_addresses = darwin_relocate_section_addresses;
  628.   darwin_so_ops.free_so = darwin_free_so;
  629.   darwin_so_ops.clear_solib = darwin_clear_solib;
  630.   darwin_so_ops.solib_create_inferior_hook = darwin_solib_create_inferior_hook;
  631.   darwin_so_ops.special_symbol_handling = darwin_special_symbol_handling;
  632.   darwin_so_ops.current_sos = darwin_current_sos;
  633.   darwin_so_ops.open_symbol_file_object = open_symbol_file_object;
  634.   darwin_so_ops.in_dynsym_resolve_code = darwin_in_dynsym_resolve_code;
  635.   darwin_so_ops.lookup_lib_global_symbol = darwin_lookup_lib_symbol;
  636.   darwin_so_ops.bfd_open = darwin_bfd_open;
  637. }