Merge GDB 7.5.1

gdb/solib-darwin.c

 /* Handle Darwin shared libraries for GDB, the GNU Debugger.
 
    Copyright (C) 2009-2012 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
@@ skipping 23 matching lines @@
 #include "solist.h"
 #include "solib.h"
 #include "solib-svr4.h"
 
 #include "bfd-target.h"
 #include "elf-bfd.h"
 #include "exec.h"
 #include "auxv.h"
 #include "exceptions.h"
 #include "mach-o.h"
+#include "mach-o/external.h"
 
 struct gdb_dyld_image_info
 {
   /* Base address (which corresponds to the Mach-O header).  */
   CORE_ADDR mach_header;
   /* Image file path.  */
   CORE_ADDR file_path;
   /* st.m_time of image file.  */
   unsigned long mtime;
 };
 
 /* Content of inferior dyld_all_image_infos structure.
    See /usr/include/mach-o/dyld_images.h for the documentation.  */
 struct gdb_dyld_all_image_infos
 {
   /* Version (1).  */
   unsigned int version;
   /* Number of images.  */
   unsigned int count;
   /* Image description.  */
   CORE_ADDR info;
   /* Notifier (function called when a library is added or removed).  */
   CORE_ADDR notifier;
 };
 
 /* Current all_image_infos version.  */
 #define DYLD_VERSION_MIN 1
 #define DYLD_VERSION_MAX 12
 
-/* Address of structure dyld_all_image_infos in inferior.  */
-static CORE_ADDR dyld_all_image_addr;
+/* Per PSPACE specific data.  */
+struct darwin_info
+{
+  /* Address of structure dyld_all_image_infos in inferior.  */
+  CORE_ADDR all_image_addr;
 
-/* Gdb copy of dyld_all_info_infos.  */
-static struct gdb_dyld_all_image_infos dyld_all_image;
+  /* Gdb copy of dyld_all_info_infos.  */
+  struct gdb_dyld_all_image_infos all_image;
+};
+
+/* Per-program-space data key.  */
+static const struct program_space_data *solib_darwin_pspace_data;
+
+static void
+darwin_pspace_data_cleanup (struct program_space *pspace, void *arg)
+{
+  struct darwin_info *info;
+
+  info = program_space_data (pspace, solib_darwin_pspace_data);
+  xfree (info);
+}
+
+/* Get the current darwin data.  If none is found yet, add it now.  This
+   function always returns a valid object.  */
+
+static struct darwin_info *
+get_darwin_info (void)
+{
+  struct darwin_info *info;
+
+  info = program_space_data (current_program_space, solib_darwin_pspace_data);
+  if (info != NULL)
+    return info;
+
+  info = XZALLOC (struct darwin_info);
+  set_program_space_data (current_program_space,
+                          solib_darwin_pspace_data, info);
+  return info;
+}
 
 /* Return non-zero if the version in dyld_all_image is known.  */
 
 static int
-darwin_dyld_version_ok (void)
+darwin_dyld_version_ok (const struct darwin_info *info)
 {
-  return dyld_all_image.version >= DYLD_VERSION_MIN
-    && dyld_all_image.version <= DYLD_VERSION_MAX;
+  return info->all_image.version >= DYLD_VERSION_MIN
+    && info->all_image.version <= DYLD_VERSION_MAX;
 }
 
 /* Read dyld_all_image from inferior.  */
 
 static void
-darwin_load_image_infos (void)
+darwin_load_image_infos (struct darwin_info *info)
 {
   gdb_byte buf[24];
   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
   struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
   int len;
 
   /* If the structure address is not known, don't continue.  */
-  if (dyld_all_image_addr == 0)
+  if (info->all_image_addr == 0)
     return;
 
   /* The structure has 4 fields: version (4 bytes), count (4 bytes),
      info (pointer) and notifier (pointer).  */
   len = 4 + 4 + 2 * ptr_type->length;
   gdb_assert (len <= sizeof (buf));
-  memset (&dyld_all_image, 0, sizeof (dyld_all_image));
+  memset (&info->all_image, 0, sizeof (info->all_image));
 
   /* Read structure raw bytes from target.  */
-  if (target_read_memory (dyld_all_image_addr, buf, len))
+  if (target_read_memory (info->all_image_addr, buf, len))
     return;
 
   /* Extract the fields.  */
-  dyld_all_image.version = extract_unsigned_integer (buf, 4, byte_order);
-  if (!darwin_dyld_version_ok ())
+  info->all_image.version = extract_unsigned_integer (buf, 4, byte_order);
+  if (!darwin_dyld_version_ok (info))
     return;
 
-  dyld_all_image.count = extract_unsigned_integer (buf + 4, 4, byte_order);
-  dyld_all_image.info = extract_typed_address (buf + 8, ptr_type);
-  dyld_all_image.notifier = extract_typed_address
+  info->all_image.count = extract_unsigned_integer (buf + 4, 4, byte_order);
+  info->all_image.info = extract_typed_address (buf + 8, ptr_type);
+  info->all_image.notifier = extract_typed_address
     (buf + 8 + ptr_type->length, ptr_type);
 }
 
 /* Link map info to include in an allocated so_list entry.  */
 
 struct lm_info
 {
   /* The target location of lm.  */
   CORE_ADDR lm_addr;
 };
@@ skipping 73 matching lines @@
 {
   return 0;
 }
 
 /* Build a list of currently loaded shared objects.  See solib-svr4.c.  */
 
 static struct so_list *
 darwin_current_sos (void)
 {
   struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
   int ptr_len = TYPE_LENGTH (ptr_type);
   unsigned int image_info_size;
-  CORE_ADDR lm;
   struct so_list *head = NULL;
   struct so_list *tail = NULL;
   int i;
+  struct darwin_info *info = get_darwin_info ();
 
   /* Be sure image infos are loaded.  */
-  darwin_load_image_infos ();
+  darwin_load_image_infos (info);
 
-  if (!darwin_dyld_version_ok ())
+  if (!darwin_dyld_version_ok (info))
     return NULL;
 
   image_info_size = ptr_len * 3;
 
   /* Read infos for each solib.
-     This first entry is ignored as this is the executable itself.  */
-  for (i = 1; i < dyld_all_image.count; i++)
+     The first entry was rumored to be the executable itself, but this is not
+     true when a large number of shared libraries are used (table expanded ?).
+     We now check all entries, but discard executable images.  */
+  for (i = 0; i < info->all_image.count; i++)
     {
-      CORE_ADDR info = dyld_all_image.info + i * image_info_size;
+      CORE_ADDR iinfo = info->all_image.info + i * image_info_size;
       char buf[image_info_size];
       CORE_ADDR load_addr;
       CORE_ADDR path_addr;
+      struct mach_o_header_external hdr;
+      unsigned long hdr_val;
       char *file_path;
       int errcode;
       struct darwin_so_list *dnew;
       struct so_list *new;
       struct cleanup *old_chain;
 
       /* Read image info from inferior.  */
-      if (target_read_memory (info, buf, image_info_size))
+      if (target_read_memory (iinfo, buf, image_info_size))
         break;
 
       load_addr = extract_typed_address (buf, ptr_type);
       path_addr = extract_typed_address (buf + ptr_len, ptr_type);
 
+      /* Read Mach-O header from memory.  */
+      if (target_read_memory (load_addr, (char *) &hdr, sizeof (hdr) - 4))
+        break;
+      /* Discard wrong magic numbers.  Shouldn't happen.  */
+      hdr_val = extract_unsigned_integer
+        (hdr.magic, sizeof (hdr.magic), byte_order);
+      if (hdr_val != BFD_MACH_O_MH_MAGIC && hdr_val != BFD_MACH_O_MH_MAGIC_64)
+        continue;
+      /* Discard executable.  Should happen only once.  */
+      hdr_val = extract_unsigned_integer
+        (hdr.filetype, sizeof (hdr.filetype), byte_order);
+      if (hdr_val == BFD_MACH_O_MH_EXECUTE)
+        continue;
+
       target_read_string (path_addr, &file_path,
                           SO_NAME_MAX_PATH_SIZE - 1, &errcode);
       if (errcode)
         break;
 
       /* Create and fill the new so_list element.  */
       dnew = XZALLOC (struct darwin_so_list);
       new = &dnew->sl;
       old_chain = make_cleanup (xfree, dnew);
 
@@ skipping 13 matching lines @@
 
       discard_cleanups (old_chain);
     }
 
   return head;
 }
 
 /* Return 1 if PC lies in the dynamic symbol resolution code of the
    run time loader.  */
 
-int
+static int
 darwin_in_dynsym_resolve_code (CORE_ADDR pc)
 {
   return 0;
 }
 
 
 /* No special symbol handling.  */
 
 static void
 darwin_special_symbol_handling (void)
 {
 }
 
 /* Extract dyld_all_image_addr when the process was just created, assuming the
    current PC is at the entry of the dynamic linker.  */
 
 static void
-darwin_solib_get_all_image_info_addr_at_init (void)
+darwin_solib_get_all_image_info_addr_at_init (struct darwin_info *info)
 {
   gdb_byte *interp_name;
   CORE_ADDR load_addr = 0;
   bfd *dyld_bfd = NULL;
 
   /* This method doesn't work with an attached process.  */
   if (current_inferior ()->attach_flag)
     return;
 
   /* Find the program interpreter.  */
@@ skipping 20 matching lines @@
   if (!dyld_bfd)
     return;
 
   /* We find the dynamic linker's base address by examining
      the current pc (which should point at the entry point for the
      dynamic linker) and subtracting the offset of the entry point.  */
   load_addr = (regcache_read_pc (get_current_regcache ())
                - bfd_get_start_address (dyld_bfd));
 
   /* Now try to set a breakpoint in the dynamic linker.  */
-  dyld_all_image_addr =
+  info->all_image_addr =
     lookup_symbol_from_bfd (dyld_bfd, "_dyld_all_image_infos");
 
   bfd_close (dyld_bfd);
 
-  if (dyld_all_image_addr == 0)
+  if (info->all_image_addr == 0)
     return;
 
-  dyld_all_image_addr += load_addr;
+  info->all_image_addr += load_addr;
 }
 
 /* Extract dyld_all_image_addr reading it from 
    TARGET_OBJECT_DARWIN_DYLD_INFO.  */
 
 static void
-darwin_solib_read_all_image_info_addr (void)
+darwin_solib_read_all_image_info_addr (struct darwin_info *info)
 {
   gdb_byte buf[8 + 8 + 4];
   LONGEST len;
   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
 
   len = target_read (&current_target, TARGET_OBJECT_DARWIN_DYLD_INFO, NULL,
                      buf, 0, sizeof (buf));
   if (len != sizeof (buf))
     return;
 
-  dyld_all_image_addr = extract_unsigned_integer (buf, 8, byte_order);
+  info->all_image_addr = extract_unsigned_integer (buf, 8, byte_order);
 }
 
 /* Shared library startup support.  See documentation in solib-svr4.c.  */
 
 static void
 darwin_solib_create_inferior_hook (int from_tty)
 {
-  dyld_all_image_addr = 0;
+  struct darwin_info *info = get_darwin_info ();
 
-  darwin_solib_read_all_image_info_addr ();
+  info->all_image_addr = 0;
 
-  if (dyld_all_image_addr == 0)
-    darwin_solib_get_all_image_info_addr_at_init ();
+  darwin_solib_read_all_image_info_addr (info);
 
-  if (dyld_all_image_addr == 0)
+  if (info->all_image_addr == 0)
+    darwin_solib_get_all_image_info_addr_at_init (info);
+
+  if (info->all_image_addr == 0)
     return;
 
-  darwin_load_image_infos ();
+  darwin_load_image_infos (info);
 
-  if (darwin_dyld_version_ok ())
-    create_solib_event_breakpoint (target_gdbarch, dyld_all_image.notifier);
+  if (darwin_dyld_version_ok (info))
+    create_solib_event_breakpoint (target_gdbarch, info->all_image.notifier);
 }
 
 static void
 darwin_clear_solib (void)
 {
-  dyld_all_image_addr = 0;
-  dyld_all_image.version = 0;
+  struct darwin_info *info = get_darwin_info ();
+
+  info->all_image_addr = 0;
+  info->all_image.version = 0;
 }
 
 static void
 darwin_free_so (struct so_list *so)
 {
 }
 
 /* The section table is built from bfd sections using bfd VMAs.
    Relocate these VMAs according to solib info.  */
 
@@ skipping 40 matching lines @@
     perror_with_name (pathname);
 
   /* Open bfd for shared library.  */
   abfd = solib_bfd_fopen (found_pathname, found_file);
 
   res = bfd_mach_o_fat_extract (abfd, bfd_object,
                                 gdbarch_bfd_arch_info (target_gdbarch));
   if (!res)
     {
       bfd_close (abfd);