Merge GDB 7.5.1

gdb/corelow.c

 /* Core dump and executable file functions below target vector, for GDB.
 
    Copyright (C) 1986-1987, 1989, 1991-2001, 2003-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
@@ skipping 28 matching lines @@
 #include "regset.h"
 #include "symfile.h"
 #include "exec.h"
 #include "readline/readline.h"
 #include "gdb_assert.h"
 #include "exceptions.h"
 #include "solib.h"
 #include "filenames.h"
 #include "progspace.h"
 #include "objfiles.h"
-#include "wrapper.h"
-
 
 #ifndef O_LARGEFILE
 #define O_LARGEFILE 0
 #endif
 
 /* List of all available core_fns.  On gdb startup, each core file
    register reader calls deprecated_add_core_fns() to register
    information on each core format it is prepared to read.  */
 
 static struct core_fns *core_file_fns = NULL;
 
 /* The core_fns for a core file handler that is prepared to read the
    core file currently open on core_bfd.  */
 
 static struct core_fns *core_vec = NULL;
 
 /* FIXME: kettenis/20031023: Eventually this variable should
    disappear.  */
 
 struct gdbarch *core_gdbarch = NULL;
 
 /* Per-core data.  Currently, only the section table.  Note that these
    target sections are *not* mapped in the current address spaces' set
    of target sections --- those should come only from pure executable
    or shared library bfds.  The core bfd sections are an
    implementation detail of the core target, just like ptrace is for
    unix child targets.  */
 static struct target_section_table *core_data;
 
-/* True if we needed to fake the pid of the loaded core inferior.  */
-static int core_has_fake_pid = 0;
-
 static void core_files_info (struct target_ops *);
 
 static struct core_fns *sniff_core_bfd (bfd *);
 
 static int gdb_check_format (bfd *);
 
 static void core_open (char *, int);
 
 static void core_detach (struct target_ops *ops, char *, int);
 
@@ skipping 31 matching lines @@
 int
 default_core_sniffer (struct core_fns *our_fns, bfd *abfd)
 {
   int result;
 
   result = (bfd_get_flavour (abfd) == our_fns -> core_flavour);
   return (result);
 }
 
 /* Walk through the list of core functions to find a set that can
-   handle the core file open on ABFD.  Default to the first one in the
-   list if nothing matches.  Returns pointer to set that is
+   handle the core file open on ABFD.  Returns pointer to set that is
    selected.  */
 
 static struct core_fns *
 sniff_core_bfd (bfd *abfd)
 {
   struct core_fns *cf;
   struct core_fns *yummy = NULL;
   int matches = 0;;
 
   /* Don't sniff if we have support for register sets in
      CORE_GDBARCH.  */
   if (core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
     return NULL;
 
   for (cf = core_file_fns; cf != NULL; cf = cf->next)
     {
       if (cf->core_sniffer (cf, abfd))
         {
           yummy = cf;
           matches++;
         }
     }
   if (matches > 1)
     {
       warning (_("\"%s\": ambiguous core format, %d handlers match"),
                bfd_get_filename (abfd), matches);
     }
   else if (matches == 0)
-    {
-      warning (_("\"%s\": no core file handler "
-                 "recognizes format, using default"),
-               bfd_get_filename (abfd));
-    }
-  if (yummy == NULL)
-    {
-      yummy = core_file_fns;
-    }
+    error (_("\"%s\": no core file handler recognizes format"),
+           bfd_get_filename (abfd));
+
   return (yummy);
 }
 
 /* The default is to reject every core file format we see.  Either
    BFD has to recognize it, or we have to provide a function in the
    core file handler that recognizes it.  */
 
 int
 default_check_format (bfd *abfd)
 {
@@ skipping 23 matching lines @@
 static void
 core_close (int quitting)
 {
   char *name;
 
   if (core_bfd)
     {
       int pid = ptid_get_pid (inferior_ptid);
       inferior_ptid = null_ptid;    /* Avoid confusion from thread
                                        stuff.  */
-      exit_inferior_silent (pid);
+      if (pid != 0)
+        exit_inferior_silent (pid);
 
       /* Clear out solib state while the bfd is still open.  See
          comments in clear_solib in solib.c.  */
       clear_solib ();
 
-      xfree (core_data->sections);
-      xfree (core_data);
-      core_data = NULL;
-      core_has_fake_pid = 0;
+      if (core_data)
+        {
+          xfree (core_data->sections);
+          xfree (core_data);
+          core_data = NULL;
+        }
 
       name = bfd_get_filename (core_bfd);
       gdb_bfd_close_or_warn (core_bfd);
       xfree (name);
       core_bfd = NULL;
     }
   core_vec = NULL;
   core_gdbarch = NULL;
 }
 
 static void
 core_close_cleanup (void *ignore)
 {
   core_close (0/*ignored*/);
 }
 
 /* Look for sections whose names start with `.reg/' so that we can
    extract the list of threads in a core file.  */
 
 static void
 add_to_thread_list (bfd *abfd, asection *asect, void *reg_sect_arg)
 {
   ptid_t ptid;
   int core_tid;
   int pid, lwpid;
   asection *reg_sect = (asection *) reg_sect_arg;
+  int fake_pid_p = 0;
+  struct inferior *inf;
 
   if (strncmp (bfd_section_name (abfd, asect), ".reg/", 5) != 0)
     return;
 
   core_tid = atoi (bfd_section_name (abfd, asect) + 5);
 
   pid = bfd_core_file_pid (core_bfd);
   if (pid == 0)
     {
-      core_has_fake_pid = 1;
+      fake_pid_p = 1;
       pid = CORELOW_PID;
     }
 
   lwpid = core_tid;
 
-  if (current_inferior ()->pid == 0)
-    inferior_appeared (current_inferior (), pid);
+  inf = current_inferior ();
+  if (inf->pid == 0)
+    {
+      inferior_appeared (inf, pid);
+      inf->fake_pid_p = fake_pid_p;
+    }
 
   ptid = ptid_build (pid, lwpid, 0);
 
   add_thread (ptid);
 
 /* Warning, Will Robinson, looking at BFD private data! */
 
   if (reg_sect != NULL
       && asect->filepos == reg_sect->filepos)   /* Did we find .reg?  */
     inferior_ptid = ptid;                       /* Yes, make it current.  */
 }
 
 /* This routine opens and sets up the core file bfd.  */
 
 static void
 core_open (char *filename, int from_tty)
 {
   const char *p;
   int siggy;
   struct cleanup *old_chain;
   char *temp;
   bfd *temp_bfd;
   int scratch_chan;
   int flags;
+  volatile struct gdb_exception except;
 
   target_preopen (from_tty);
   if (!filename)
     {
       if (core_bfd)
         error (_("No core file specified.  (Use `detach' "
                  "to stop debugging a core file.)"));
       else
         error (_("No core file specified."));
     }
@@ skipping 76 matching lines @@
   push_target (&core_ops);
   discard_cleanups (old_chain);
 
   /* Do this before acknowledging the inferior, so if
      post_create_inferior throws (can happen easilly if you're loading
      a core file with the wrong exec), we aren't left with threads
      from the previous inferior.  */
   init_thread_list ();
 
   inferior_ptid = null_ptid;
-  core_has_fake_pid = 0;
 
   /* Need to flush the register cache (and the frame cache) from a
      previous debug session.  If inferior_ptid ends up the same as the
      last debug session --- e.g., b foo; run; gcore core1; step; gcore
      core2; core core1; core core2 --- then there's potential for
      get_current_regcache to return the cached regcache of the
      previous session, and the frame cache being stale.  */
   registers_changed ();
 
   /* Build up thread list from BFD sections, and possibly set the
@@ skipping 21 matching lines @@
       else
         switch_to_thread (thread->ptid);
     }
 
   post_create_inferior (&core_ops, from_tty);
 
   /* Now go through the target stack looking for threads since there
      may be a thread_stratum target loaded on top of target core by
      now.  The layer above should claim threads found in the BFD
      sections.  */
-  gdb_target_find_new_threads ();
+  TRY_CATCH (except, RETURN_MASK_ERROR)
+    {
+      target_find_new_threads ();
+    }
+
+  if (except.reason < 0)
+    exception_print (gdb_stderr, except);
 
   p = bfd_core_file_failing_command (core_bfd);
   if (p)
     printf_filtered (_("Core was generated by `%s'.\n"), p);
 
   siggy = bfd_core_file_failing_signal (core_bfd);
   if (siggy > 0)
     {
-      /* NOTE: target_signal_from_host() converts a target signal
-         value into gdb's internal signal value.  Unfortunately gdb's
-         internal value is called ``target_signal'' and this function
-         got the name ..._from_host().  */
-      enum target_signal sig = (core_gdbarch != NULL
-                       ? gdbarch_target_signal_from_host (core_gdbarch,
-                                                          siggy)
-                       : target_signal_from_host (siggy));
+      /* If we don't have a CORE_GDBARCH to work with, assume a native
+         core (map gdb_signal from host signals).  If we do have
+         CORE_GDBARCH to work with, but no gdb_signal_from_target
+         implementation for that gdbarch, as a fallback measure,
+         assume the host signal mapping.  It'll be correct for native
+         cores, but most likely incorrect for cross-cores.  */
+      enum gdb_signal sig = (core_gdbarch != NULL
+                             && gdbarch_gdb_signal_from_target_p (core_gdbarch)
+                             ? gdbarch_gdb_signal_from_target (core_gdbarch,
+                                                               siggy)
+                             : gdb_signal_from_host (siggy));
 
       printf_filtered (_("Program terminated with signal %d, %s.\n"),
-                       siggy, target_signal_to_string (sig));
+                       siggy, gdb_signal_to_string (sig));
     }
 
   /* Fetch all registers from core file.  */
   target_fetch_registers (get_current_regcache (), -1);
 
   /* Now, set up the frame cache, and print the top of stack.  */
   reinit_frame_cache ();
   print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
 }
 
@@ skipping 376 matching lines @@
 
 static const struct target_desc *
 core_read_description (struct target_ops *target)
 {
   if (core_gdbarch && gdbarch_core_read_description_p (core_gdbarch))
     return gdbarch_core_read_description (core_gdbarch, 
                                           target, core_bfd);
 
   return NULL;
 }