/* Generate a core file for the inferior process.
- Copyright 2001, 2002 Free Software Foundation, Inc.
+
+ Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
+ 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 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,
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., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
-#include "cli/cli-decode.h"
+#include "elf-bfd.h"
+#include "infcall.h"
#include "inferior.h"
#include "gdbcore.h"
-#include "elf-bfd.h"
-#include <sys/procfs.h>
-#include "symfile.h"
#include "objfiles.h"
+#include "symfile.h"
-static 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 *);
+#include "cli/cli-decode.h"
+
+#include "gdb_assert.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)
-/* Function: gcore_command
- Generate a core file from the inferior process. */
+static 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 *);
+
+/* Generate a core file from the inferior process. */
static void
gcore_command (char *args, int from_tty)
{
struct cleanup *old_chain;
char *corefilename, corefilename_buffer[40];
- asection *note_sec;
+ asection *note_sec = NULL;
bfd *obfd;
void *note_data = NULL;
int note_size = 0;
/* No use generating a corefile without a target process. */
- if (!(target_has_execution))
+ if (!target_has_execution)
noprocess ();
if (args && *args)
}
if (info_verbose)
- fprintf_filtered (gdb_stdout,
+ fprintf_filtered (gdb_stdout,
"Opening corefile '%s' for output.\n", corefilename);
- /* Open the output file. */
- if (!(obfd = bfd_openw (corefilename, NULL /*default_gcore_target ()*/)))
- {
- error ("Failed to open '%s' for output.", corefilename);
- }
+ /* Open the output file. */
+ obfd = bfd_openw (corefilename, default_gcore_target ());
+ if (!obfd)
+ error (_("Failed to open '%s' for output."), corefilename);
- /* Need a cleanup that will close the file (FIXME: delete it?). */
+ /* 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 = (char *) target_make_corefile_notes (obfd, ¬e_size);
+ /* An external target method must build the notes section. */
+ note_data = target_make_corefile_notes (obfd, ¬e_size);
- /* Create the note section. */
+ /* Create the note section. */
if (note_data != NULL && note_size != 0)
{
- if ((note_sec = bfd_make_section_anyway (obfd, "note0")) == NULL)
- error ("Failed to create 'note' section for corefile: %s",
+ 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 (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. */
+ /* Now create the memory/load sections. */
if (gcore_memory_sections (obfd) == 0)
- error ("gcore: failed to get corefile memory sections from target.");
+ error (_("gcore: failed to get corefile memory sections from target."));
- /* Write out the contents of the note section. */
+ /* 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 ()));
- }
+ warning (_("writing note section (%s)"), bfd_errmsg (bfd_get_error ()));
}
- /* Succeeded. */
- fprintf_filtered (gdb_stdout,
- "Saved corefile %s\n", corefilename);
+ /* Succeeded. */
+ fprintf_filtered (gdb_stdout, "Saved corefile %s\n", corefilename);
- /* Clean-ups will close the output file and free malloc memory. */
+ /* Clean-ups will close the output file and free malloc memory. */
do_cleanups (old_chain);
return;
}
static unsigned long
default_gcore_mach (void)
{
-#ifdef TARGET_ARCHITECTURE
- const struct bfd_arch_info * bfdarch = TARGET_ARCHITECTURE;
+#if 1 /* See if this even matters... */
+ return 0;
+#else
+
+ const struct bfd_arch_info *bfdarch = gdbarch_bfd_arch_info (current_gdbarch);
if (bfdarch != NULL)
return bfdarch->mach;
-#endif
if (exec_bfd == NULL)
- error ("Can't find default bfd machine type (need execfile).");
+ error (_("Can't find default bfd machine type (need execfile)."));
return bfd_get_mach (exec_bfd);
+#endif /* 1 */
}
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
+ (current_gdbarch);
if (bfdarch != NULL)
return bfdarch->arch;
-#endif
if (exec_bfd == NULL)
- error ("Can't find bfd architecture for corefile (need execfile).");
+ error (_("Can't find bfd architecture for corefile (need execfile)."));
return bfd_get_arch (exec_bfd);
}
static char *
default_gcore_target (void)
{
- /* FIXME -- this may only work for ELF targets. */
+ /* FIXME: This may only work for ELF targets. */
if (exec_bfd == NULL)
- error ("Can't find default bfd target for corefile (need execfile).");
-
- return bfd_get_target (exec_bfd);
-}
-
-/*
- * Default method for stack segment (preemptable by target).
- */
-
-static int (*override_derive_stack_segment) (bfd_vma *, bfd_vma *);
-
-extern void
-preempt_derive_stack_segment (int (*override_func) (bfd_vma *, bfd_vma *))
-{
- override_derive_stack_segment = override_func;
+ return NULL;
+ else
+ return bfd_get_target (exec_bfd);
}
-/* Function: default_derive_stack_segment
- Derive a reasonable stack segment by unwinding the target stack.
-
- Returns 0 for failure, 1 for success. */
+/* Derive a reasonable stack segment by unwinding the target stack,
+ and store its limits in *BOTTOM and *TOP. Return non-zero if
+ successful. */
-static int
-default_derive_stack_segment (bfd_vma *bottom, bfd_vma *top)
+static int
+derive_stack_segment (bfd_vma *bottom, bfd_vma *top)
{
- bfd_vma tmp_vma;
struct frame_info *fi, *tmp_fi;
- if (bottom == NULL || top == NULL)
- return 0; /* Paranoia. */
+ gdb_assert (bottom);
+ gdb_assert (top);
+ /* Can't succeed without stack and registers. */
if (!target_has_stack || !target_has_registers)
- return 0; /* Can't succeed without stack and registers. */
+ return 0;
- if ((fi = get_current_frame ()) == NULL)
- return 0; /* Can't succeed without current frame. */
+ /* Can't succeed without current frame. */
+ fi = get_current_frame ();
+ if (fi == NULL)
+ return 0;
- /* Save frame pointer of TOS frame. */
- *top = fi->frame;
- /* If current stack pointer is more "inner", use that instead. */
- if (INNER_THAN (read_sp (), *top))
- *top = read_sp ();
+ /* Save frame pointer of TOS frame. */
+ *top = get_frame_base (fi);
+ /* If current stack pointer is more "inner", use that instead. */
+ if (gdbarch_inner_than (get_frame_arch (fi), get_frame_sp (fi), *top))
+ *top = get_frame_sp (fi);
- /* Find prev-most frame. */
+ /* Find prev-most frame. */
while ((tmp_fi = get_prev_frame (fi)) != NULL)
fi = tmp_fi;
- /* Save frame pointer of prev-most frame. */
- *bottom = fi->frame;
+ /* Save frame pointer of prev-most frame. */
+ *bottom = get_frame_base (fi);
- /* Now canonicalize their order, so that 'bottom' is a lower address
- (as opposed to a lower stack frame). */
+ /* Now canonicalize their order, so that BOTTOM is a lower address
+ (as opposed to a lower stack frame). */
if (*bottom > *top)
{
+ bfd_vma tmp_vma;
+
tmp_vma = *top;
*top = *bottom;
*bottom = tmp_vma;
}
- return 1; /* success */
-}
-
-static int
-derive_stack_segment (bfd_vma *bottom, bfd_vma *top)
-{
- if (override_derive_stack_segment)
- return override_derive_stack_segment (bottom, top);
- else
- return default_derive_stack_segment (bottom, top);
-}
-
-/*
- * Default method for heap segment (preemptable by target).
- */
-
-static int (*override_derive_heap_segment) (bfd *, bfd_vma *, bfd_vma *);
-
-extern void
-preempt_derive_heap_segment (int (*override_func) (bfd *,
- bfd_vma *, bfd_vma *))
-{
- override_derive_heap_segment = override_func;
+ return 1;
}
-/* Function: default_derive_heap_segment
- Derive a reasonable heap segment by looking at sbrk and
- the static data sections.
-
- Returns 0 for failure, 1 for success. */
+/* 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. */
-static int
-default_derive_heap_segment (bfd *abfd, bfd_vma *bottom, bfd_vma *top)
+static int
+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_vma sec_vaddr;
asection *sec;
- if (bottom == NULL || top == NULL)
- return 0; /* Paranoia. */
+ gdb_assert (bottom);
+ gdb_assert (top);
+ /* This function depends on being able to call a function in the
+ inferior. */
if (!target_has_execution)
- return 0; /* This function depends on being able
- to call a function in the inferior. */
+ return 0;
+
+ /* The following code assumes that the link map is arranged as
+ follows (low to high addresses):
- /* Assumption: link map is arranged as follows (low to high addresses):
- text sections
- data sections (including bss)
- heap
- */
+ ---------------------------------
+ | text sections |
+ ---------------------------------
+ | data sections (including bss) |
+ ---------------------------------
+ | heap |
+ --------------------------------- */
for (sec = abfd->sections; sec; sec = sec->next)
{
- if (bfd_get_section_flags (abfd, sec) & SEC_DATA ||
- strcmp (".bss", bfd_get_section_name (abfd, sec)) == 0)
+ if (bfd_get_section_flags (abfd, sec) & SEC_DATA
+ || strcmp (".bss", bfd_section_name (abfd, sec)) == 0)
{
sec_vaddr = bfd_get_section_vma (abfd, sec);
- sec_size = bfd_get_section_size_before_reloc (sec);
+ sec_size = bfd_get_section_size (sec);
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 ((sbrk = find_function_in_inferior ("sbrk")) == NULL)
- return 0;
- if ((zero = value_from_longest (builtin_type_int, (LONGEST) 0)) == NULL)
+ 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
return 0;
- if ((sbrk = call_function_by_hand (sbrk, 1, &zero)) == NULL)
+
+ 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. */
+ /* Return results. */
if (top_of_heap > top_of_data_memory)
{
*bottom = top_of_data_memory;
*top = top_of_heap;
- return 1; /* success */
+ return 1;
}
- else
- return 0; /* No additional heap space needs to be saved. */
-}
-static int
-derive_heap_segment (bfd *abfd, bfd_vma *bottom, bfd_vma *top)
-{
- if (override_derive_heap_segment)
- return override_derive_heap_segment (abfd, bottom, top);
- else
- return default_derive_heap_segment (abfd, bottom, top);
+ /* No additional heap space needs to be saved. */
+ return 0;
}
-/* ARGSUSED */
static void
make_output_phdrs (bfd *obfd, asection *osec, void *ignored)
{
int p_type;
/* FIXME: these constants may only be applicable for ELF. */
- if (strncmp (osec->name, "load", 4) == 0)
+ if (strncmp (bfd_section_name (obfd, osec), "load", 4) == 0)
p_type = PT_LOAD;
else
p_type = PT_NOTE;
if (bfd_get_section_flags (obfd, 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);
+ bfd_record_phdr (obfd, p_type, 1, p_flags, 0, 0, 0, 0, 1, &osec);
}
-static asection *
-make_mem_sec (bfd *obfd,
- bfd_vma addr,
- bfd_size_type size,
- unsigned int flags,
- unsigned int alignment)
+static int
+gcore_create_callback (CORE_ADDR vaddr, unsigned long size,
+ int read, int write, int exec, void *data)
{
+ bfd *obfd = data;
asection *osec;
+ flagword flags = SEC_ALLOC | SEC_HAS_CONTENTS | SEC_LOAD;
- if ((osec = bfd_make_section_anyway (obfd, "load")) == NULL)
+ /* 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)
{
- warning ("Couldn't make gcore segment: %s",
- bfd_errmsg (bfd_get_error ()));
- return NULL;
- }
+ if (info_verbose)
+ {
+ fprintf_filtered (gdb_stdout, "Ignore segment, %s bytes at 0x%s\n",
+ paddr_d (size), paddr_nz (vaddr));
+ }
- if (info_verbose)
- {
- fprintf_filtered (gdb_stdout,
- "Save segment, %ld bytes at 0x%s\n",
- size, paddr_nz (addr));
+ return 0;
}
- bfd_set_section_size (obfd, osec, size);
- bfd_set_section_vma (obfd, osec, addr);
- osec->lma = 0; /* FIXME: there should be a macro for this! */
- bfd_set_section_alignment (obfd, osec, alignment);
- bfd_set_section_flags (obfd, osec,
- flags | SEC_LOAD | SEC_ALLOC | SEC_HAS_CONTENTS);
- return osec;
-}
-
-static int
-gcore_create_callback (CORE_ADDR vaddr,
- unsigned long size,
- int read, int write, int exec,
- void *data)
-{
- flagword flags = 0;
-
if (write == 0)
{
+ /* 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;
+
+ 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;
+ flags |= SEC_NEVER_LOAD;
+ goto keep; /* break out of two nested for loops */
+ }
+ }
+
+ keep:
flags |= SEC_READONLY;
- /* Set size == zero for readonly sections. */
- size = 0;
}
+
if (exec)
+ flags |= SEC_CODE;
+ else
+ flags |= SEC_DATA;
+
+ osec = bfd_make_section_anyway_with_flags (obfd, "load", flags);
+ if (osec == NULL)
{
- flags |= SEC_CODE;
+ warning (_("Couldn't make gcore segment: %s"),
+ bfd_errmsg (bfd_get_error ()));
+ return 1;
}
- else
+
+ if (info_verbose)
{
- flags |= SEC_DATA;
+ fprintf_filtered (gdb_stdout, "Save segment, %s bytes at 0x%s\n",
+ paddr_d (size), paddr_nz (vaddr));
}
- return ((make_mem_sec ((bfd *) data, vaddr, size, flags, 0)) == NULL);
+ bfd_set_section_size (obfd, osec, size);
+ bfd_set_section_vma (obfd, osec, vaddr);
+ bfd_section_lma (obfd, osec) = 0; /* ??? bfd_set_section_lma? */
+ return 0;
}
static int
-objfile_find_memory_regions (int (*func) (CORE_ADDR,
- unsigned long,
- int, int, int,
- void *),
+objfile_find_memory_regions (int (*func) (CORE_ADDR, unsigned long,
+ int, int, int, void *),
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. */
+ /* Call callback function for each objfile section. */
ALL_OBJSECTIONS (objfile, objsec)
{
bfd *ibfd = objfile->obfd;
int size = bfd_section_size (ibfd, isec);
int ret;
- if ((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)) != 0)
+ 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;
}
}
- /* Make a stack segment. */
+ /* Make a stack segment. */
if (derive_stack_segment (&temp_bottom, &temp_top))
- (*func) (temp_bottom,
- temp_top - temp_bottom,
- 1, /* Stack section will be readable */
- 1, /* Stack section will be writable */
- 0, /* Stack section will not be executable */
+ (*func) (temp_bottom, temp_top - temp_bottom,
+ 1, /* Stack section will be readable. */
+ 1, /* Stack section will be writable. */
+ 0, /* Stack section will not be executable. */
obfd);
/* 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 */
+ (*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. */
obfd);
+
return 0;
}
static void
gcore_copy_callback (bfd *obfd, asection *osec, void *ignored)
{
- bfd_size_type size = bfd_section_size (obfd, osec);
+ bfd_size_type size, total_size = bfd_section_size (obfd, osec);
+ file_ptr offset = 0;
struct cleanup *old_chain = NULL;
void *memhunk;
- if (size == 0)
- return; /* Read-only sections are marked as zero-size.
- We don't have to copy their contents. */
- if (strncmp ("load", bfd_get_section_name (obfd, osec), 4) != 0)
- return; /* Only interested in "load" sections. */
+ /* Read-only sections are marked; we don't have to copy their contents. */
+ if ((bfd_get_section_flags (obfd, osec) & SEC_LOAD) == 0)
+ return;
+
+ /* Only interested in "load" sections. */
+ if (strncmp ("load", bfd_section_name (obfd, osec), 4) != 0)
+ return;
- if ((memhunk = xmalloc (size)) == NULL)
- error ("Not enough memory to create corefile.");
+ size = min (total_size, MAX_COPY_BYTES);
+ 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, %ld bytes at 0x%s\n",
- (long) 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 ()));
+ while (total_size > 0)
+ {
+ if (size > total_size)
+ size = total_size;
+
+ if (target_read_memory (bfd_section_vma (obfd, osec) + offset,
+ memhunk, size) != 0)
+ {
+ warning (_("Memory read failed for corefile section, %s bytes at 0x%s."),
+ paddr_d (size), paddr (bfd_section_vma (obfd, osec)));
+ break;
+ }
+ if (!bfd_set_section_contents (obfd, osec, memhunk, offset, size))
+ {
+ warning (_("Failed to write corefile contents (%s)."),
+ bfd_errmsg (bfd_get_error ()));
+ break;
+ }
+
+ total_size -= size;
+ offset += size;
+ }
- do_cleanups (old_chain); /* frees the xmalloc buffer */
+ do_cleanups (old_chain); /* Frees MEMHUNK. */
}
static int
gcore_memory_sections (bfd *obfd)
{
if (target_find_memory_regions (gcore_create_callback, obfd) != 0)
- return 0; /* FIXME error return/msg? */
+ return 0; /* FIXME: error return/msg? */
- /* Record phdrs for section-to-segment mapping. */
+ /* Record phdrs for section-to-segment mapping. */
bfd_map_over_sections (obfd, make_output_phdrs, NULL);
- /* Copy memory region contents. */
+ /* Copy memory region contents. */
bfd_map_over_sections (obfd, gcore_copy_callback, NULL);
- return 1; /* success */
+ return 1;
}
void
_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\
-Argument is optional filename. Default filename is 'core.<process_id>'.");
+ 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>'."));
add_com_alias ("gcore", "generate-core-file", class_files, 1);
exec_set_find_memory_regions (objfile_find_memory_regions);
projects / deliverable / binutils-gdb.git / blobdiff