Change objfile::partial_symtabs to be a unique_ptr

[deliverable/binutils-gdb.git] / gdb / gcore.c

diff --git a/gdb/gcore.c b/gdb/gcore.c
index 6d9ae0664109d68fd72b9faaeba173931c304e61..f283ed4580d9f2266dafeafcd09b88eca8a311fd 100644 (file)
--- a/gdb/gcore.c
+++ b/gdb/gcore.c
@@ -1,12 +1,12 @@
 /* Generate a core file for the inferior process.
 
 /* Generate a core file for the inferior process.
 

-   Copyright (C) 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
+   Copyright (C) 2001-2019 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
 
    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 2 of the License, or
+   the Free Software Foundation; either version 3 of the License, or

    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,


@@ -15,9 +15,7 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License

-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, USA.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

 
 #include "defs.h"
 #include "elf-bfd.h"
 
 #include "defs.h"
 #include "elf-bfd.h"


@@ -25,92 +23,141 @@
 #include "inferior.h"
 #include "gdbcore.h"
 #include "objfiles.h"
 #include "inferior.h"
 #include "gdbcore.h"
 #include "objfiles.h"

+#include "solib.h"

 #include "symfile.h"
 #include "symfile.h"

-
+#include "arch-utils.h"
+#include "completer.h"
+#include "gcore.h"

 #include "cli/cli-decode.h"
 #include "cli/cli-decode.h"

-
-#include "gdb_assert.h"
-
-static char *default_gcore_target (void);
+#include <fcntl.h>
+#include "regcache.h"
+#include "regset.h"
+#include "gdb_bfd.h"
+#include "readline/tilde.h"
+#include <algorithm>
+#include "gdbsupport/gdb_unlinker.h"
+#include "gdbsupport/byte-vector.h"
+#include "gdbsupport/scope-exit.h"
+
+/* The largest amount of memory to read from the target at once.  We
+   must throttle it to limit the amount of memory used by GDB during
+   generate-core-file for programs with large resident data.  */
+#define MAX_COPY_BYTES (1024 * 1024)
+
+static const char *default_gcore_target (void);

 static enum bfd_architecture default_gcore_arch (void);
 static unsigned long default_gcore_mach (void);
 static int gcore_memory_sections (bfd *);
 
 static enum bfd_architecture default_gcore_arch (void);
 static unsigned long default_gcore_mach (void);
 static int gcore_memory_sections (bfd *);
 

-/* Generate a core file from the inferior process.  */
+/* create_gcore_bfd -- helper for gcore_command (exported).
+   Open a new bfd core file for output, and return the handle.  */
+
+gdb_bfd_ref_ptr
+create_gcore_bfd (const char *filename)
+{
+  gdb_bfd_ref_ptr obfd (gdb_bfd_openw (filename, default_gcore_target ()));
+
+  if (obfd == NULL)
+    error (_("Failed to open '%s' for output."), filename);
+  bfd_set_format (obfd.get (), bfd_core);
+  bfd_set_arch_mach (obfd.get (), default_gcore_arch (), default_gcore_mach ());
+  return obfd;
+}
+
+/* write_gcore_file_1 -- do the actual work of write_gcore_file.  */

 
 static void
 
 static void

-gcore_command (char *args, int from_tty)
+write_gcore_file_1 (bfd *obfd)

 {
 {

-  struct cleanup *old_chain;
-  char *corefilename, corefilename_buffer[40];
-  asection *note_sec = NULL;
-  bfd *obfd;
-  void *note_data = NULL;
+  gdb::unique_xmalloc_ptr<char> note_data;

   int note_size = 0;
   int note_size = 0;

+  asection *note_sec = NULL;
+
+  /* An external target method must build the notes section.  */
+  /* FIXME: uweigand/2011-10-06: All architectures that support core file
+     generation should be converted to gdbarch_make_corefile_notes; at that
+     point, the target vector method can be removed.  */
+  if (!gdbarch_make_corefile_notes_p (target_gdbarch ()))
+    note_data.reset (target_make_corefile_notes (obfd, &note_size));
+  else
+    note_data.reset (gdbarch_make_corefile_notes (target_gdbarch (), obfd,
+                                                 &note_size));
+
+  if (note_data == NULL || note_size == 0)
+    error (_("Target does not support core file generation."));
+
+  /* Create the note section.  */
+  note_sec = bfd_make_section_anyway_with_flags (obfd, "note0",
+                                                SEC_HAS_CONTENTS
+                                                | SEC_READONLY
+                                                | SEC_ALLOC);
+  if (note_sec == NULL)
+    error (_("Failed to create 'note' section for corefile: %s"),
+          bfd_errmsg (bfd_get_error ()));
+
+  bfd_set_section_vma (note_sec, 0);
+  bfd_set_section_alignment (note_sec, 0);
+  bfd_set_section_size (note_sec, note_size);
+
+  /* Now create the memory/load sections.  */
+  if (gcore_memory_sections (obfd) == 0)
+    error (_("gcore: failed to get corefile memory sections from target."));
+
+  /* Write out the contents of the note section.  */
+  if (!bfd_set_section_contents (obfd, note_sec, note_data.get (), 0,
+                                note_size))
+    warning (_("writing note section (%s)"), bfd_errmsg (bfd_get_error ()));
+}
+
+/* write_gcore_file -- helper for gcore_command (exported).
+   Compose and write the corefile data to the core file.  */
+
+void
+write_gcore_file (bfd *obfd)
+{
+  target_prepare_to_generate_core ();
+  SCOPE_EXIT { target_done_generating_core (); };
+  write_gcore_file_1 (obfd);
+}
+
+/* gcore_command -- implements the 'gcore' command.
+   Generate a core file from the inferior process.  */
+
+static void
+gcore_command (const char *args, int from_tty)
+{
+  gdb::unique_xmalloc_ptr<char> corefilename;

 
   /* No use generating a corefile without a target process.  */
   if (!target_has_execution)
     noprocess ();
 
   if (args && *args)
 
   /* No use generating a corefile without a target process.  */
   if (!target_has_execution)
     noprocess ();
 
   if (args && *args)

-    corefilename = args;
+    corefilename.reset (tilde_expand (args));

   else
     {
       /* Default corefile name is "core.PID".  */
   else
     {
       /* Default corefile name is "core.PID".  */

-      sprintf (corefilename_buffer, "core.%d", PIDGET (inferior_ptid));
-      corefilename = corefilename_buffer;
+      corefilename.reset (xstrprintf ("core.%d", inferior_ptid.pid ()));

     }
 
   if (info_verbose)
     fprintf_filtered (gdb_stdout,
     }
 
   if (info_verbose)
     fprintf_filtered (gdb_stdout,

-                     "Opening corefile '%s' for output.\n", corefilename);
+                     "Opening corefile '%s' for output.\n",
+                     corefilename.get ());

 
   /* Open the output file.  */
 
   /* Open the output file.  */

-  obfd = bfd_openw (corefilename, default_gcore_target ());
-  if (!obfd)
-    error (_("Failed to open '%s' for output."), corefilename);
+  gdb_bfd_ref_ptr obfd (create_gcore_bfd (corefilename.get ()));

 
 

-  /* Need a cleanup that will close the file (FIXME: delete it?).  */
-  old_chain = make_cleanup_bfd_close (obfd);
-
-  bfd_set_format (obfd, bfd_core);
-  bfd_set_arch_mach (obfd, default_gcore_arch (), default_gcore_mach ());
-
-  /* An external target method must build the notes section.  */
-  note_data = target_make_corefile_notes (obfd, &note_size);
+  /* Arrange to unlink the file on failure.  */
+  gdb::unlinker unlink_file (corefilename.get ());

 
 

-  /* Create the note section.  */
-  if (note_data != NULL && note_size != 0)
-    {
-      note_sec = bfd_make_section_anyway (obfd, "note0");
-      if (note_sec == NULL)
-       error (_("Failed to create 'note' section for corefile: %s"),
-              bfd_errmsg (bfd_get_error ()));
-
-      bfd_set_section_vma (obfd, note_sec, 0);
-      bfd_set_section_flags (obfd, note_sec,
-                            SEC_HAS_CONTENTS | SEC_READONLY | SEC_ALLOC);
-      bfd_set_section_alignment (obfd, note_sec, 0);
-      bfd_set_section_size (obfd, note_sec, note_size);
-    }
-
-  /* Now create the memory/load sections.  */
-  if (gcore_memory_sections (obfd) == 0)
-    error (_("gcore: failed to get corefile memory sections from target."));
-
-  /* Write out the contents of the note section.  */
-  if (note_data != NULL && note_size != 0)
-    {
-      if (!bfd_set_section_contents (obfd, note_sec, note_data, 0, note_size))
-       warning (_("writing note section (%s)"), bfd_errmsg (bfd_get_error ()));
-    }
+  /* Call worker function.  */
+  write_gcore_file (obfd.get ());

 
   /* Succeeded.  */
 
   /* Succeeded.  */

-  fprintf_filtered (gdb_stdout, "Saved corefile %s\n", corefilename);
+  unlink_file.keep ();

 
 

-  /* Clean-ups will close the output file and free malloc memory.  */
-  do_cleanups (old_chain);
-  return;
+  fprintf_filtered (gdb_stdout, "Saved corefile %s\n", corefilename.get ());

 }
 
 static unsigned long
 }
 
 static unsigned long


@@ -119,12 +166,11 @@ default_gcore_mach (void)
 #if 1  /* See if this even matters...  */
   return 0;
 #else
 #if 1  /* See if this even matters...  */
   return 0;
 #else

-#ifdef TARGET_ARCHITECTURE
-  const struct bfd_arch_info *bfdarch = TARGET_ARCHITECTURE;
+
+  const struct bfd_arch_info *bfdarch = gdbarch_bfd_arch_info (target_gdbarch ());

 
   if (bfdarch != NULL)
     return bfdarch->mach;
 
   if (bfdarch != NULL)
     return bfdarch->mach;

-#endif /* TARGET_ARCHITECTURE */

   if (exec_bfd == NULL)
     error (_("Can't find default bfd machine type (need execfile)."));
 
   if (exec_bfd == NULL)
     error (_("Can't find default bfd machine type (need execfile)."));
 


@@ -135,22 +181,25 @@ default_gcore_mach (void)
 static enum bfd_architecture
 default_gcore_arch (void)
 {
 static enum bfd_architecture
 default_gcore_arch (void)
 {

-#ifdef TARGET_ARCHITECTURE
-  const struct bfd_arch_info * bfdarch = TARGET_ARCHITECTURE;
+  const struct bfd_arch_info *bfdarch = gdbarch_bfd_arch_info (target_gdbarch ());

 
   if (bfdarch != NULL)
     return bfdarch->arch;
 
   if (bfdarch != NULL)
     return bfdarch->arch;

-#endif

   if (exec_bfd == NULL)
     error (_("Can't find bfd architecture for corefile (need execfile)."));
 
   return bfd_get_arch (exec_bfd);
 }
 
   if (exec_bfd == NULL)
     error (_("Can't find bfd architecture for corefile (need execfile)."));
 
   return bfd_get_arch (exec_bfd);
 }
 

-static char *
+static const char *

 default_gcore_target (void)
 {
 default_gcore_target (void)
 {

-  /* FIXME: This may only work for ELF targets.  */
+  /* The gdbarch may define a target to use for core files.  */
+  if (gdbarch_gcore_bfd_target_p (target_gdbarch ()))
+    return gdbarch_gcore_bfd_target (target_gdbarch ());
+
+  /* Otherwise, try to fall back to the exec_bfd target.  This will probably
+     not work for non-ELF targets.  */

   if (exec_bfd == NULL)
     return NULL;
   else
   if (exec_bfd == NULL)
     return NULL;
   else


@@ -181,8 +230,8 @@ derive_stack_segment (bfd_vma *bottom, bfd_vma *top)
   /* Save frame pointer of TOS frame.  */
   *top = get_frame_base (fi);
   /* If current stack pointer is more "inner", use that instead.  */
   /* Save frame pointer of TOS frame.  */
   *top = get_frame_base (fi);
   /* If current stack pointer is more "inner", use that instead.  */

-  if (INNER_THAN (read_sp (), *top))
-    *top = read_sp ();
+  if (gdbarch_inner_than (get_frame_arch (fi), get_frame_sp (fi), *top))
+    *top = get_frame_sp (fi);

 
   /* Find prev-most frame.  */
   while ((tmp_fi = get_prev_frame (fi)) != NULL)
 
   /* Find prev-most frame.  */
   while ((tmp_fi = get_prev_frame (fi)) != NULL)


@@ -205,6 +254,50 @@ derive_stack_segment (bfd_vma *bottom, bfd_vma *top)
   return 1;
 }
 
   return 1;
 }
 

+/* call_target_sbrk --
+   helper function for derive_heap_segment.  */
+
+static bfd_vma
+call_target_sbrk (int sbrk_arg)
+{
+  struct objfile *sbrk_objf;
+  struct gdbarch *gdbarch;
+  bfd_vma top_of_heap;
+  struct value *target_sbrk_arg;
+  struct value *sbrk_fn, *ret;
+  bfd_vma tmp;
+
+  if (lookup_minimal_symbol ("sbrk", NULL, NULL).minsym != NULL)
+    {
+      sbrk_fn = find_function_in_inferior ("sbrk", &sbrk_objf);
+      if (sbrk_fn == NULL)
+       return (bfd_vma) 0;
+    }
+  else if (lookup_minimal_symbol ("_sbrk", NULL, NULL).minsym != NULL)
+    {
+      sbrk_fn = find_function_in_inferior ("_sbrk", &sbrk_objf);
+      if (sbrk_fn == NULL)
+       return (bfd_vma) 0;
+    }
+  else
+    return (bfd_vma) 0;
+
+  gdbarch = get_objfile_arch (sbrk_objf);
+  target_sbrk_arg = value_from_longest (builtin_type (gdbarch)->builtin_int, 
+                                       sbrk_arg);
+  gdb_assert (target_sbrk_arg);
+  ret = call_function_by_hand (sbrk_fn, NULL, target_sbrk_arg);
+  if (ret == NULL)
+    return (bfd_vma) 0;
+
+  tmp = value_as_long (ret);
+  if ((LONGEST) tmp <= 0 || (LONGEST) tmp == 0xffffffff)
+    return (bfd_vma) 0;
+
+  top_of_heap = tmp;
+  return top_of_heap;
+}
+

 /* Derive a reasonable heap segment for ABFD by looking at sbrk and
    the static data sections.  Store its limits in *BOTTOM and *TOP.
    Return non-zero if successful.  */
 /* Derive a reasonable heap segment for ABFD by looking at sbrk and
    the static data sections.  Store its limits in *BOTTOM and *TOP.
    Return non-zero if successful.  */


@@ -215,7 +308,6 @@ derive_heap_segment (bfd *abfd, bfd_vma *bottom, bfd_vma *top)
   bfd_vma top_of_data_memory = 0;
   bfd_vma top_of_heap = 0;
   bfd_size_type sec_size;
   bfd_vma top_of_data_memory = 0;
   bfd_vma top_of_heap = 0;
   bfd_size_type sec_size;

-  struct value *zero, *sbrk;

   bfd_vma sec_vaddr;
   asection *sec;
 
   bfd_vma sec_vaddr;
   asection *sec;
 


@@ -240,39 +332,20 @@ derive_heap_segment (bfd *abfd, bfd_vma *bottom, bfd_vma *top)
 
   for (sec = abfd->sections; sec; sec = sec->next)
     {
 
   for (sec = abfd->sections; sec; sec = sec->next)
     {

-      if (bfd_get_section_flags (abfd, sec) & SEC_DATA
-         || strcmp (".bss", bfd_section_name (abfd, sec)) == 0)
+      if (bfd_section_flags (sec) & SEC_DATA
+         || strcmp (".bss", bfd_section_name (sec)) == 0)

        {
        {

-         sec_vaddr = bfd_get_section_vma (abfd, sec);
-         sec_size = bfd_get_section_size (sec);
+         sec_vaddr = bfd_section_vma (sec);
+         sec_size = bfd_section_size (sec);

          if (sec_vaddr + sec_size > top_of_data_memory)
            top_of_data_memory = sec_vaddr + sec_size;
        }
     }
 
          if (sec_vaddr + sec_size > top_of_data_memory)
            top_of_data_memory = sec_vaddr + sec_size;
        }
     }
 

-  /* Now get the top-of-heap by calling sbrk in the inferior.  */
-  if (lookup_minimal_symbol ("sbrk", NULL, NULL) != NULL)
-    {
-      sbrk = find_function_in_inferior ("sbrk");
-      if (sbrk == NULL)
-       return 0;
-    }
-  else if (lookup_minimal_symbol ("_sbrk", NULL, NULL) != NULL)
-    {
-      sbrk = find_function_in_inferior ("_sbrk");
-      if (sbrk == NULL)
-       return 0;
-    }
-  else
+  top_of_heap = call_target_sbrk (0);
+  if (top_of_heap == (bfd_vma) 0)

     return 0;
 
     return 0;
 

-  zero = value_from_longest (builtin_type_int, 0);
-  gdb_assert (zero);
-  sbrk = call_function_by_hand (sbrk, 1, &zero);
-  if (sbrk == NULL)
-    return 0;
-  top_of_heap = value_as_long (sbrk);
-

   /* Return results.  */
   if (top_of_heap > top_of_data_memory)
     {
   /* Return results.  */
   if (top_of_heap > top_of_data_memory)
     {


@@ -289,86 +362,94 @@ static void
 make_output_phdrs (bfd *obfd, asection *osec, void *ignored)
 {
   int p_flags = 0;
 make_output_phdrs (bfd *obfd, asection *osec, void *ignored)
 {
   int p_flags = 0;

-  int p_type;
+  int p_type = 0;

 
   /* FIXME: these constants may only be applicable for ELF.  */
 
   /* FIXME: these constants may only be applicable for ELF.  */

-  if (strncmp (bfd_section_name (obfd, osec), "load", 4) == 0)
+  if (startswith (bfd_section_name (osec), "load"))

     p_type = PT_LOAD;
     p_type = PT_LOAD;

-  else
+  else if (startswith (bfd_section_name (osec), "note"))

     p_type = PT_NOTE;
     p_type = PT_NOTE;

+  else
+    p_type = PT_NULL;

 
   p_flags |= PF_R;     /* Segment is readable.  */
 
   p_flags |= PF_R;     /* Segment is readable.  */

-  if (!(bfd_get_section_flags (obfd, osec) & SEC_READONLY))
+  if (!(bfd_section_flags (osec) & SEC_READONLY))

     p_flags |= PF_W;   /* Segment is writable.  */
     p_flags |= PF_W;   /* Segment is writable.  */

-  if (bfd_get_section_flags (obfd, osec) & SEC_CODE)
+  if (bfd_section_flags (osec) & SEC_CODE)

     p_flags |= PF_X;   /* Segment is executable.  */
 
   bfd_record_phdr (obfd, p_type, 1, p_flags, 0, 0, 0, 0, 1, &osec);
 }
 
     p_flags |= PF_X;   /* Segment is executable.  */
 
   bfd_record_phdr (obfd, p_type, 1, p_flags, 0, 0, 0, 0, 1, &osec);
 }
 

+/* find_memory_region_ftype implementation.  DATA is 'bfd *' for the core file
+   GDB is creating.  */
+

 static int
 static int

-gcore_create_callback (CORE_ADDR vaddr, unsigned long size,
-                      int read, int write, int exec, void *data)
+gcore_create_callback (CORE_ADDR vaddr, unsigned long size, int read,
+                      int write, int exec, int modified, void *data)

 {
 {

-  bfd *obfd = data;
+  bfd *obfd = (bfd *) data;

   asection *osec;
   flagword flags = SEC_ALLOC | SEC_HAS_CONTENTS | SEC_LOAD;
 
   /* If the memory segment has no permissions set, ignore it, otherwise
      when we later try to access it for read/write, we'll get an error
      or jam the kernel.  */
   asection *osec;
   flagword flags = SEC_ALLOC | SEC_HAS_CONTENTS | SEC_LOAD;
 
   /* If the memory segment has no permissions set, ignore it, otherwise
      when we later try to access it for read/write, we'll get an error
      or jam the kernel.  */

-  if (read == 0 && write == 0 && exec == 0)
+  if (read == 0 && write == 0 && exec == 0 && modified == 0)

     {
       if (info_verbose)
         {
     {
       if (info_verbose)
         {

-          fprintf_filtered (gdb_stdout, "Ignore segment, %s bytes at 0x%s\n",
-                           paddr_d (size), paddr_nz (vaddr));
+          fprintf_filtered (gdb_stdout, "Ignore segment, %s bytes at %s\n",
+                            plongest (size), paddress (target_gdbarch (), vaddr));

         }
 
       return 0;
     }
 
         }
 
       return 0;
     }
 

-  if (write == 0)
+  if (write == 0 && modified == 0 && !solib_keep_data_in_core (vaddr, size))

     {
       /* See if this region of memory lies inside a known file on disk.
         If so, we can avoid copying its contents by clearing SEC_LOAD.  */
     {
       /* See if this region of memory lies inside a known file on disk.
         If so, we can avoid copying its contents by clearing SEC_LOAD.  */

-      struct objfile *objfile;

       struct obj_section *objsec;
 
       struct obj_section *objsec;
 

-      ALL_OBJSECTIONS (objfile, objsec)
-       {
-         bfd *abfd = objfile->obfd;
-         asection *asec = objsec->the_bfd_section;
-         bfd_vma align = (bfd_vma) 1 << bfd_get_section_alignment (abfd,
-                                                                   asec);
-         bfd_vma start = objsec->addr & -align;
-         bfd_vma end = (objsec->endaddr + align - 1) & -align;
-         /* Match if either the entire memory region lies inside the
-            section (i.e. a mapping covering some pages of a large
-            segment) or the entire section lies inside the memory region
-            (i.e. a mapping covering multiple small sections).
-
-            This BFD was synthesized from reading target memory,
-            we don't want to omit that.  */
-         if (((vaddr >= start && vaddr + size <= end)
-              || (start >= vaddr && end <= vaddr + size))
-             && !(bfd_get_file_flags (abfd) & BFD_IN_MEMORY))
-           {
-             flags &= ~SEC_LOAD;
-             goto keep;        /* break out of two nested for loops */
-           }
-       }
-
-    keep:
-      flags |= SEC_READONLY;
+      for (objfile *objfile : current_program_space->objfiles ())
+       ALL_OBJFILE_OSECTIONS (objfile, objsec)
+         {
+           bfd *abfd = objfile->obfd;
+           asection *asec = objsec->the_bfd_section;
+           bfd_vma align = (bfd_vma) 1 << bfd_section_alignment (asec);
+           bfd_vma start = obj_section_addr (objsec) & -align;
+           bfd_vma end = (obj_section_endaddr (objsec) + align - 1) & -align;
+
+           /* Match if either the entire memory region lies inside the
+              section (i.e. a mapping covering some pages of a large
+              segment) or the entire section lies inside the memory region
+              (i.e. a mapping covering multiple small sections).
+
+              This BFD was synthesized from reading target memory,
+              we don't want to omit that.  */
+           if (objfile->separate_debug_objfile_backlink == NULL
+               && ((vaddr >= start && vaddr + size <= end)
+                   || (start >= vaddr && end <= vaddr + size))
+               && !(bfd_get_file_flags (abfd) & BFD_IN_MEMORY))
+             {
+               flags &= ~(SEC_LOAD | SEC_HAS_CONTENTS);
+               goto keep;      /* Break out of two nested for loops.  */
+             }
+         }
+
+    keep:;

     }
 
     }
 

+  if (write == 0)
+    flags |= SEC_READONLY;
+

   if (exec)
     flags |= SEC_CODE;
   else
     flags |= SEC_DATA;
 
   if (exec)
     flags |= SEC_CODE;
   else
     flags |= SEC_DATA;
 

-  osec = bfd_make_section_anyway (obfd, "load");
+  osec = bfd_make_section_anyway_with_flags (obfd, "load", flags);

   if (osec == NULL)
     {
       warning (_("Couldn't make gcore segment: %s"),
   if (osec == NULL)
     {
       warning (_("Couldn't make gcore segment: %s"),


@@ -378,49 +459,50 @@ gcore_create_callback (CORE_ADDR vaddr, unsigned long size,
 
   if (info_verbose)
     {
 
   if (info_verbose)
     {

-      fprintf_filtered (gdb_stdout, "Save segment, %s bytes at 0x%s\n",
-                       paddr_d (size), paddr_nz (vaddr));
+      fprintf_filtered (gdb_stdout, "Save segment, %s bytes at %s\n",
+                       plongest (size), paddress (target_gdbarch (), vaddr));

     }
 
     }
 

-  bfd_set_section_size (obfd, osec, size);
-  bfd_set_section_vma (obfd, osec, vaddr);
-  bfd_section_lma (obfd, osec) = 0; /* ??? bfd_set_section_lma?  */
-  bfd_set_section_flags (obfd, osec, flags);
+  bfd_set_section_size (osec, size);
+  bfd_set_section_vma (osec, vaddr);
+  bfd_set_section_lma (osec, 0);

   return 0;
 }
 
   return 0;
 }
 

-static int
-objfile_find_memory_regions (int (*func) (CORE_ADDR, unsigned long,
-                                         int, int, int, void *),
-                            void *obfd)
+int
+objfile_find_memory_regions (struct target_ops *self,
+                            find_memory_region_ftype func, void *obfd)

 {
   /* Use objfile data to create memory sections.  */
 {
   /* Use objfile data to create memory sections.  */

-  struct objfile *objfile;

   struct obj_section *objsec;
   bfd_vma temp_bottom, temp_top;
 
   /* Call callback function for each objfile section.  */
   struct obj_section *objsec;
   bfd_vma temp_bottom, temp_top;
 
   /* Call callback function for each objfile section.  */

-  ALL_OBJSECTIONS (objfile, objsec)
-    {
-      bfd *ibfd = objfile->obfd;
-      asection *isec = objsec->the_bfd_section;
-      flagword flags = bfd_get_section_flags (ibfd, isec);
-      int ret;
-
-      if ((flags & SEC_ALLOC) || (flags & SEC_LOAD))
-       {
-         int size = bfd_section_size (ibfd, isec);
-         int ret;
-
-         ret = (*func) (objsec->addr, bfd_section_size (ibfd, isec),
-                        1, /* All sections will be readable.  */
-                        (flags & SEC_READONLY) == 0, /* Writable.  */
-                        (flags & SEC_CODE) != 0, /* Executable.  */
-                        obfd);
-         if (ret != 0)
-           return ret;
-       }
-    }
+  for (objfile *objfile : current_program_space->objfiles ())
+    ALL_OBJFILE_OSECTIONS (objfile, objsec)
+      {
+       asection *isec = objsec->the_bfd_section;
+       flagword flags = bfd_section_flags (isec);
+
+       /* Separate debug info files are irrelevant for gcore.  */
+       if (objfile->separate_debug_objfile_backlink != NULL)
+         continue;
+
+       if ((flags & SEC_ALLOC) || (flags & SEC_LOAD))
+         {
+           int size = bfd_section_size (isec);
+           int ret;
+
+           ret = (*func) (obj_section_addr (objsec), size, 
+                          1, /* All sections will be readable.  */
+                          (flags & SEC_READONLY) == 0, /* Writable.  */
+                          (flags & SEC_CODE) != 0, /* Executable.  */
+                          1, /* MODIFIED is unknown, pass it as true.  */
+                          obfd);
+           if (ret != 0)
+             return ret;
+         }
+      }

 
   /* Make a stack segment.  */
   if (derive_stack_segment (&temp_bottom, &temp_top))
 
   /* Make a stack segment.  */
   if (derive_stack_segment (&temp_bottom, &temp_top))


@@ -428,14 +510,16 @@ objfile_find_memory_regions (int (*func) (CORE_ADDR, unsigned long,
             1, /* Stack section will be readable.  */
             1, /* Stack section will be writable.  */
             0, /* Stack section will not be executable.  */
             1, /* Stack section will be readable.  */
             1, /* Stack section will be writable.  */
             0, /* Stack section will not be executable.  */

+            1, /* Stack section will be modified.  */

             obfd);
 
             obfd);
 

-  /* Make a heap segment. */
+  /* Make a heap segment.  */

   if (derive_heap_segment (exec_bfd, &temp_bottom, &temp_top))
     (*func) (temp_bottom, temp_top - temp_bottom,
             1, /* Heap section will be readable.  */
             1, /* Heap section will be writable.  */
             0, /* Heap section will not be executable.  */
   if (derive_heap_segment (exec_bfd, &temp_bottom, &temp_top))
     (*func) (temp_bottom, temp_top - temp_bottom,
             1, /* Heap section will be readable.  */
             1, /* Heap section will be writable.  */
             0, /* Heap section will not be executable.  */

+            1, /* Heap section will be modified.  */

             obfd);
 
   return 0;
             obfd);
 
   return 0;


@@ -444,40 +528,58 @@ objfile_find_memory_regions (int (*func) (CORE_ADDR, unsigned long,
 static void
 gcore_copy_callback (bfd *obfd, asection *osec, void *ignored)
 {
 static void
 gcore_copy_callback (bfd *obfd, asection *osec, void *ignored)
 {

-  bfd_size_type size = bfd_section_size (obfd, osec);
-  struct cleanup *old_chain = NULL;
-  void *memhunk;
+  bfd_size_type size, total_size = bfd_section_size (osec);
+  file_ptr offset = 0;

 
   /* Read-only sections are marked; we don't have to copy their contents.  */
 
   /* Read-only sections are marked; we don't have to copy their contents.  */

-  if ((bfd_get_section_flags (obfd, osec) & SEC_LOAD) == 0)
+  if ((bfd_section_flags (osec) & SEC_LOAD) == 0)

     return;
 
   /* Only interested in "load" sections.  */
     return;
 
   /* Only interested in "load" sections.  */

-  if (strncmp ("load", bfd_section_name (obfd, osec), 4) != 0)
+  if (!startswith (bfd_section_name (osec), "load"))

     return;
 
     return;
 

-  memhunk = xmalloc (size);
-  /* ??? This is crap since xmalloc should never return NULL.  */
-  if (memhunk == NULL)
-    error (_("Not enough memory to create corefile."));
-  old_chain = make_cleanup (xfree, memhunk);
-
-  if (target_read_memory (bfd_section_vma (obfd, osec),
-                         memhunk, size) != 0)
-    warning (_("Memory read failed for corefile section, %s bytes at 0x%s."),
-            paddr_d (size), paddr (bfd_section_vma (obfd, osec)));
-  if (!bfd_set_section_contents (obfd, osec, memhunk, 0, size))
-    warning (_("Failed to write corefile contents (%s)."),
-            bfd_errmsg (bfd_get_error ()));
-
-  do_cleanups (old_chain);     /* Frees MEMHUNK.  */
+  size = std::min (total_size, (bfd_size_type) MAX_COPY_BYTES);
+  gdb::byte_vector memhunk (size);
+
+  while (total_size > 0)
+    {
+      if (size > total_size)
+       size = total_size;
+
+      if (target_read_memory (bfd_section_vma (osec) + offset,
+                             memhunk.data (), size) != 0)
+       {
+         warning (_("Memory read failed for corefile "
+                    "section, %s bytes at %s."),
+                  plongest (size),
+                  paddress (target_gdbarch (), bfd_section_vma (osec)));
+         break;
+       }
+      if (!bfd_set_section_contents (obfd, osec, memhunk.data (),
+                                    offset, size))
+       {
+         warning (_("Failed to write corefile contents (%s)."),
+                  bfd_errmsg (bfd_get_error ()));
+         break;
+       }
+
+      total_size -= size;
+      offset += size;
+    }

 }
 
 static int
 gcore_memory_sections (bfd *obfd)
 {
 }
 
 static int
 gcore_memory_sections (bfd *obfd)
 {

-  if (target_find_memory_regions (gcore_create_callback, obfd) != 0)
-    return 0;                  /* FIXME: error return/msg?  */
+  /* Try gdbarch method first, then fall back to target method.  */
+  if (!gdbarch_find_memory_regions_p (target_gdbarch ())
+      || gdbarch_find_memory_regions (target_gdbarch (),
+                                     gcore_create_callback, obfd) != 0)
+    {
+      if (target_find_memory_regions (gcore_create_callback, obfd) != 0)
+       return 0;                       /* FIXME: error return/msg?  */
+    }

 
   /* Record phdrs for section-to-segment mapping.  */
   bfd_map_over_sections (obfd, make_output_phdrs, NULL);
 
   /* Record phdrs for section-to-segment mapping.  */
   bfd_map_over_sections (obfd, make_output_phdrs, NULL);


@@ -493,8 +595,8 @@ _initialize_gcore (void)
 {
   add_com ("generate-core-file", class_files, gcore_command, _("\
 Save a core file with the current state of the debugged process.\n\
 {
   add_com ("generate-core-file", class_files, gcore_command, _("\
 Save a core file with the current state of the debugged process.\n\

-Argument is optional filename.  Default filename is 'core.<process_id>'."));
+Usage: generate-core-file [FILENAME]\n\
+Argument is optional filename.  Default filename is 'core.PROCESS_ID'."));

 
   add_com_alias ("gcore", "generate-core-file", class_files, 1);
 
   add_com_alias ("gcore", "generate-core-file", class_files, 1);

-  exec_set_find_memory_regions (objfile_find_memory_regions);

 }
 }