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

/* Generate a core file for the inferior process.
   Copyright 2001, 2002 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
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   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.  */

#include "defs.h"
#include "cli/cli-decode.h"
#include "inferior.h"
#include "gdbcore.h"
#include "elf-bfd.h"
#include "symfile.h"
#include "objfiles.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 *);

/* Function: gcore_command
   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 = NULL;
  bfd *obfd;
  void *note_data = NULL;
  int note_size = 0;

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

  if (args && *args)
    corefilename = args;
  else
    {
      /* Default corefile name is "core.PID".  */
      sprintf (corefilename_buffer, "core.%d", PIDGET (inferior_ptid));
      corefilename = corefilename_buffer;
    }

  if (info_verbose)
    fprintf_filtered (gdb_stdout, 
		      "Opening corefile '%s' for output.\n", corefilename);

  /* Open the output file. */
  if (!(obfd = bfd_openw (corefilename, default_gcore_target ())))
    {
      error ("Failed to open '%s' for output.", corefilename);
    }

  /* 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, &note_size);

  /* 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", 
	       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 ()));
	}
    }

  /* Succeeded. */
  fprintf_filtered (gdb_stdout, 
		    "Saved corefile %s\n", corefilename);

  /* Clean-ups will close the output file and free malloc memory. */
  do_cleanups (old_chain);
  return;
}

static unsigned long
default_gcore_mach (void)
{
#if 1	/* See if this even matters... */
  return 0;
#else
#ifdef TARGET_ARCHITECTURE
  const struct bfd_arch_info * bfdarch = TARGET_ARCHITECTURE;

  if (bfdarch != NULL)
    return bfdarch->mach;
#endif /* TARGET_ARCHITECTURE */
  if (exec_bfd == NULL)
    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;

  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);
}

static char *
default_gcore_target (void)
{
  /* FIXME -- this may only work for ELF targets.  */
  if (exec_bfd == NULL)
    return NULL;
  else
    return bfd_get_target (exec_bfd);
}

/* Function: derive_stack_segment

   Derive a reasonable stack segment by unwinding the target stack. 
   
   Returns 0 for failure, 1 for success.  */

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

  if (!target_has_stack || !target_has_registers)
    return 0;	/* Can't succeed without stack and registers. */

  if ((fi = get_current_frame ()) == NULL)
    return 0;	/* Can't succeed without current frame. */

  /* 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 ();

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

  /* Now canonicalize their order, so that 'bottom' is a lower address
   (as opposed to a lower stack frame). */
  if (*bottom > *top)
    {
      tmp_vma = *top;
      *top = *bottom;
      *bottom = tmp_vma;
    }

  return 1;	/* success */
}

/* Function: derive_heap_segment

   Derive a reasonable heap segment by looking at sbrk and
   the static data sections.
   
   Returns 0 for failure, 1 for success.  */

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_size_type sec_size;
  struct value *zero, *sbrk;
  bfd_vma sec_vaddr;
  asection *sec;

  if (bottom == NULL || top == NULL)
    return 0;		/* Paranoia. */

  if (!target_has_execution)
    return 0;		/* This function depends on being able
			   to call a function in the inferior.  */

  /* Assumption: link map is arranged as follows (low to high addresses):
     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_section_name (abfd, sec)) == 0)
	{
	  sec_vaddr = bfd_get_section_vma (abfd, sec);
	  sec_size = bfd_get_section_size_before_reloc (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 (lookup_minimal_symbol ("sbrk", NULL, NULL) != NULL)
    {
      if ((sbrk = find_function_in_inferior ("sbrk")) == NULL)
	return 0;
    }
  else if (lookup_minimal_symbol ("_sbrk", NULL, NULL) != NULL)
    {
      if ((sbrk = find_function_in_inferior ("_sbrk")) == NULL)
	return 0;
    }
  else
    return 0;

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

  /* Return results. */
  if (top_of_heap > top_of_data_memory)
    {
      *bottom = top_of_data_memory;
      *top = top_of_heap;
      return 1;	/* success */
    }
  else
    return 0;	/* No additional heap space needs to be saved. */
}

/* ARGSUSED */
static void
make_output_phdrs (bfd *obfd, asection *osec, void *ignored)
{
  int p_flags = 0;
  int p_type;

  /* FIXME: these constants may only be applicable for ELF.  */
  if (strncmp (bfd_section_name (obfd, osec), "load", 4) == 0)
    p_type = PT_LOAD;
  else
    p_type = PT_NOTE;

  p_flags |= PF_R;	/* Segment is readable.  */
  if (!(bfd_get_section_flags (obfd, osec) & SEC_READONLY))
    p_flags |= PF_W;	/* Segment is writable.  */
  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);
}

static asection *
make_mem_sec (bfd *obfd, 
	      bfd_vma addr, 
	      bfd_size_type size, 
	      unsigned int flags, 
	      unsigned int alignment)
{
  asection *osec;

  if ((osec = bfd_make_section_anyway (obfd, "load")) == NULL)
    {
      warning ("Couldn't make gcore segment: %s",
	       bfd_errmsg (bfd_get_error ()));
      return NULL;
    }

  if (info_verbose)
    {
      fprintf_filtered (gdb_stdout, 
			"Save segment, %lld bytes at 0x%s\n",
			(long long) size, paddr_nz (addr));
    }

  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)
    {
      flags |= SEC_READONLY;
      /* Set size == zero for readonly sections. */
      size = 0;
    }
  if (exec)
    {
      flags |= SEC_CODE;
    }
  else
    {
      flags |= SEC_DATA;
    }

  return ((make_mem_sec ((bfd *) data, vaddr, size, flags, 0)) == NULL);
}

static int
objfile_find_memory_regions (int (*func) (CORE_ADDR, 
					  unsigned long,
					  int, int, int,
					   void *), 
			     void *obfd)
{
  /* 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. */
  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;

	  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)
	    return ret;
	}
    }

  /* 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 */
	     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 */
	     obfd);
  return 0;
}

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;

  if (size == 0)
    return;	/* Read-only sections are marked as zero-size.
		   We don't have to copy their contents. */
  if (strncmp ("load", bfd_section_name (obfd, osec), 4) != 0)
    return;	/* Only interested in "load" sections. */

  if ((memhunk = xmalloc (size)) == 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 ()));

  do_cleanups (old_chain);	/* frees the xmalloc buffer */
}

static int
gcore_memory_sections (bfd *obfd)
{
  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);

  /* Copy memory region contents. */
  bfd_map_over_sections (obfd, gcore_copy_callback, NULL);

  return 1;	/* success */
}

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_alias ("gcore", "generate-core-file", class_files, 1);
  exec_set_find_memory_regions (objfile_find_memory_regions);
}
Commit	Line	Data
be4d1333 MS	1	/* Generate a core file for the inferior process.
	2	Copyright 2001, 2002 Free Software Foundation, Inc.
	3
	4	This file is part of GDB.
	5
	6	This program is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 2 of the License, or
	9	(at your option) any later version.
	10
	11	This program is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with this program; if not, write to the Free Software
	18	Foundation, Inc., 59 Temple Place - Suite 330,
	19	Boston, MA 02111-1307, USA. */
	20
	21	#include "defs.h"
c18be923	22	#include "cli/cli-decode.h"
be4d1333 MS	23	#include "inferior.h"
	24	#include "gdbcore.h"
	25	#include "elf-bfd.h"
be4d1333 MS	26	#include "symfile.h"
	27	#include "objfiles.h"
	28
	29	static char *default_gcore_target (void);
	30	static enum bfd_architecture default_gcore_arch (void);
	31	static unsigned long default_gcore_mach (void);
	32	static int gcore_memory_sections (bfd *);
	33
	34	/* Function: gcore_command
	35	Generate a core file from the inferior process. */
	36
	37	static void
	38	gcore_command (char *args, int from_tty)
	39	{
	40	struct cleanup *old_chain;
	41	char *corefilename, corefilename_buffer[40];
356ae49d	42	asection *note_sec = NULL;
be4d1333 MS	43	bfd *obfd;
	44	void *note_data = NULL;
	45	int note_size = 0;
	46
	47	/* No use generating a corefile without a target process. */
	48	if (!(target_has_execution))
	49	noprocess ();
	50
	51	if (args && *args)
	52	corefilename = args;
	53	else
	54	{
	55	/* Default corefile name is "core.PID". */
	56	sprintf (corefilename_buffer, "core.%d", PIDGET (inferior_ptid));
	57	corefilename = corefilename_buffer;
	58	}
	59
	60	if (info_verbose)
	61	fprintf_filtered (gdb_stdout,
	62	"Opening corefile '%s' for output.\n", corefilename);
	63
	64	/* Open the output file. */
6dbdc4a3	65	if (!(obfd = bfd_openw (corefilename, default_gcore_target ())))
be4d1333 MS	66	{
	67	error ("Failed to open '%s' for output.", corefilename);
	68	}
	69
	70	/* Need a cleanup that will close the file (FIXME: delete it?). */
	71	old_chain = make_cleanup_bfd_close (obfd);
	72
	73	bfd_set_format (obfd, bfd_core);
	74	bfd_set_arch_mach (obfd, default_gcore_arch (), default_gcore_mach ());
	75
	76	/* An external target method must build the notes section. */
	77	note_data = (char *) target_make_corefile_notes (obfd, &note_size);
	78
	79	/* Create the note section. */
	80	if (note_data != NULL && note_size != 0)
	81	{
	82	if ((note_sec = bfd_make_section_anyway (obfd, "note0")) == NULL)
	83	error ("Failed to create 'note' section for corefile: %s",
	84	bfd_errmsg (bfd_get_error ()));
	85
	86	bfd_set_section_vma (obfd, note_sec, 0);
	87	bfd_set_section_flags (obfd, note_sec,
	88	SEC_HAS_CONTENTS \| SEC_READONLY \| SEC_ALLOC);
	89	bfd_set_section_alignment (obfd, note_sec, 0);
	90	bfd_set_section_size (obfd, note_sec, note_size);
	91	}
	92
	93	/* Now create the memory/load sections. */
	94	if (gcore_memory_sections (obfd) == 0)
	95	error ("gcore: failed to get corefile memory sections from target.");
	96
	97	/* Write out the contents of the note section. */
	98	if (note_data != NULL && note_size != 0)
	99	{
	100	if (!bfd_set_section_contents (obfd, note_sec, note_data, 0, note_size))
	101	{
	102	warning ("writing note section (%s)",
	103	bfd_errmsg (bfd_get_error ()));
	104	}
	105	}
	106
	107	/* Succeeded. */
	108	fprintf_filtered (gdb_stdout,
	109	"Saved corefile %s\n", corefilename);
	110
	111	/* Clean-ups will close the output file and free malloc memory. */
	112	do_cleanups (old_chain);
	113	return;
	114	}
	115
	116	static unsigned long
	117	default_gcore_mach (void)
	118	{
6dbdc4a3 MS	119	#if 1 /* See if this even matters... */
	120	return 0;
	121	#else
be4d1333 MS	122	#ifdef TARGET_ARCHITECTURE
	123	const struct bfd_arch_info * bfdarch = TARGET_ARCHITECTURE;
	124
	125	if (bfdarch != NULL)
	126	return bfdarch->mach;
6dbdc4a3	127	#endif /* TARGET_ARCHITECTURE */
be4d1333 MS	128	if (exec_bfd == NULL)
	129	error ("Can't find default bfd machine type (need execfile).");
	130
	131	return bfd_get_mach (exec_bfd);
6dbdc4a3	132	#endif /* 1 */
be4d1333 MS	133	}
	134
	135	static enum bfd_architecture
	136	default_gcore_arch (void)
	137	{
	138	#ifdef TARGET_ARCHITECTURE
	139	const struct bfd_arch_info * bfdarch = TARGET_ARCHITECTURE;
	140
	141	if (bfdarch != NULL)
	142	return bfdarch->arch;
	143	#endif
	144	if (exec_bfd == NULL)
	145	error ("Can't find bfd architecture for corefile (need execfile).");
	146
	147	return bfd_get_arch (exec_bfd);
	148	}
	149
	150	static char *
	151	default_gcore_target (void)
	152	{
	153	/* FIXME -- this may only work for ELF targets. */
	154	if (exec_bfd == NULL)
6dbdc4a3 MS	155	return NULL;
	156	else
	157	return bfd_get_target (exec_bfd);
be4d1333 MS	158	}
be4d1333 MS	159
69db8bae	160	/* Function: derive_stack_segment
be4d1333	161
be4d1333 MS	162	Derive a reasonable stack segment by unwinding the target stack.
	163
	164	Returns 0 for failure, 1 for success. */
	165
	166	static int
69db8bae	167	derive_stack_segment (bfd_vma bottom, bfd_vma top)
be4d1333 MS	168	{
	169	bfd_vma tmp_vma;
	170	struct frame_info fi, tmp_fi;
	171
	172	if (bottom == NULL \|\| top == NULL)
	173	return 0; /* Paranoia. */
	174
	175	if (!target_has_stack \|\| !target_has_registers)
	176	return 0; /* Can't succeed without stack and registers. */
	177
	178	if ((fi = get_current_frame ()) == NULL)
	179	return 0; /* Can't succeed without current frame. */
	180
	181	/* Save frame pointer of TOS frame. */
	182	*top = fi->frame;
	183	/* If current stack pointer is more "inner", use that instead. */
	184	if (INNER_THAN (read_sp (), *top))
	185	*top = read_sp ();
	186
	187	/* Find prev-most frame. */
	188	while ((tmp_fi = get_prev_frame (fi)) != NULL)
	189	fi = tmp_fi;
	190
	191	/* Save frame pointer of prev-most frame. */
	192	*bottom = fi->frame;
	193
	194	/* Now canonicalize their order, so that 'bottom' is a lower address
	195	(as opposed to a lower stack frame). */
	196	if (bottom > top)
	197	{
	198	tmp_vma = *top;
	199	top = bottom;
	200	*bottom = tmp_vma;
	201	}
	202
	203	return 1; /* success */
	204	}
	205
69db8bae	206	/* Function: derive_heap_segment
be4d1333	207
be4d1333 MS	208	Derive a reasonable heap segment by looking at sbrk and
	209	the static data sections.
	210
	211	Returns 0 for failure, 1 for success. */
	212
	213	static int
69db8bae	214	derive_heap_segment (bfd abfd, bfd_vma bottom, bfd_vma *top)
be4d1333 MS	215	{
	216	bfd_vma top_of_data_memory = 0;
	217	bfd_vma top_of_heap = 0;
	218	bfd_size_type sec_size;
	219	struct value zero, sbrk;
	220	bfd_vma sec_vaddr;
	221	asection *sec;
	222
	223	if (bottom == NULL \|\| top == NULL)
	224	return 0; /* Paranoia. */
	225
	226	if (!target_has_execution)
	227	return 0; /* This function depends on being able
	228	to call a function in the inferior. */
	229
	230	/* Assumption: link map is arranged as follows (low to high addresses):
	231	text sections
	232	data sections (including bss)
	233	heap
	234	*/
	235
	236	for (sec = abfd->sections; sec; sec = sec->next)
	237	{
	238	if (bfd_get_section_flags (abfd, sec) & SEC_DATA \|\|
20fe79c8	239	strcmp (".bss", bfd_section_name (abfd, sec)) == 0)
be4d1333 MS	240	{
	241	sec_vaddr = bfd_get_section_vma (abfd, sec);
	242	sec_size = bfd_get_section_size_before_reloc (sec);
	243	if (sec_vaddr + sec_size > top_of_data_memory)
	244	top_of_data_memory = sec_vaddr + sec_size;
	245	}
	246	}
	247	/* Now get the top-of-heap by calling sbrk in the inferior. */
20fe79c8 MS	248	if (lookup_minimal_symbol ("sbrk", NULL, NULL) != NULL)
	249	{
	250	if ((sbrk = find_function_in_inferior ("sbrk")) == NULL)
	251	return 0;
	252	}
	253	else if (lookup_minimal_symbol ("_sbrk", NULL, NULL) != NULL)
	254	{
	255	if ((sbrk = find_function_in_inferior ("_sbrk")) == NULL)
	256	return 0;
	257	}
	258	else
be4d1333	259	return 0;
20fe79c8	260
be4d1333 MS	261	if ((zero = value_from_longest (builtin_type_int, (LONGEST) 0)) == NULL)
	262	return 0;
	263	if ((sbrk = call_function_by_hand (sbrk, 1, &zero)) == NULL)
	264	return 0;
	265	top_of_heap = value_as_long (sbrk);
	266
	267	/* Return results. */
	268	if (top_of_heap > top_of_data_memory)
	269	{
	270	*bottom = top_of_data_memory;
	271	*top = top_of_heap;
	272	return 1; /* success */
	273	}
	274	else
	275	return 0; /* No additional heap space needs to be saved. */
	276	}
	277
be4d1333 MS	278	/* ARGSUSED */
	279	static void
	280	make_output_phdrs (bfd obfd, asection osec, void *ignored)
	281	{
	282	int p_flags = 0;
	283	int p_type;
	284
	285	/* FIXME: these constants may only be applicable for ELF. */
20fe79c8	286	if (strncmp (bfd_section_name (obfd, osec), "load", 4) == 0)
be4d1333 MS	287	p_type = PT_LOAD;
	288	else
	289	p_type = PT_NOTE;
	290
	291	p_flags \|= PF_R; /* Segment is readable. */
	292	if (!(bfd_get_section_flags (obfd, osec) & SEC_READONLY))
	293	p_flags \|= PF_W; /* Segment is writable. */
	294	if (bfd_get_section_flags (obfd, osec) & SEC_CODE)
	295	p_flags \|= PF_X; /* Segment is executable. */
	296
	297	bfd_record_phdr (obfd, p_type, 1, p_flags, 0, 0,
	298	0, 0, 1, &osec);
	299	}
	300
	301	static asection *
	302	make_mem_sec (bfd *obfd,
	303	bfd_vma addr,
	304	bfd_size_type size,
	305	unsigned int flags,
	306	unsigned int alignment)
	307	{
	308	asection *osec;
	309
	310	if ((osec = bfd_make_section_anyway (obfd, "load")) == NULL)
	311	{
	312	warning ("Couldn't make gcore segment: %s",
	313	bfd_errmsg (bfd_get_error ()));
	314	return NULL;
	315	}
	316
	317	if (info_verbose)
	318	{
	319	fprintf_filtered (gdb_stdout,
6dbdc4a3 MS	320	"Save segment, %lld bytes at 0x%s\n",
6dbdc4a3 MS	321	(long long) size, paddr_nz (addr));
be4d1333 MS	322	}
	323
	324	bfd_set_section_size (obfd, osec, size);
	325	bfd_set_section_vma (obfd, osec, addr);
	326	osec->lma = 0; /* FIXME: there should be a macro for this! */
	327	bfd_set_section_alignment (obfd, osec, alignment);
	328	bfd_set_section_flags (obfd, osec,
	329	flags \| SEC_LOAD \| SEC_ALLOC \| SEC_HAS_CONTENTS);
	330	return osec;
	331	}
	332
	333	static int
	334	gcore_create_callback (CORE_ADDR vaddr,
	335	unsigned long size,
	336	int read, int write, int exec,
	337	void *data)
	338	{
	339	flagword flags = 0;
	340
	341	if (write == 0)
	342	{
	343	flags \|= SEC_READONLY;
	344	/* Set size == zero for readonly sections. */
	345	size = 0;
	346	}
	347	if (exec)
	348	{
	349	flags \|= SEC_CODE;
	350	}
	351	else
	352	{
	353	flags \|= SEC_DATA;
	354	}
	355
	356	return ((make_mem_sec ((bfd *) data, vaddr, size, flags, 0)) == NULL);
	357	}
	358
	359	static int
	360	objfile_find_memory_regions (int (*func) (CORE_ADDR,
	361	unsigned long,
	362	int, int, int,
	363	void *),
	364	void *obfd)
	365	{
	366	/* Use objfile data to create memory sections. */
	367	struct objfile *objfile;
	368	struct obj_section *objsec;
	369	bfd_vma temp_bottom, temp_top;
	370
	371	/* Call callback function for each objfile section. */
	372	ALL_OBJSECTIONS (objfile, objsec)
	373	{
	374	bfd *ibfd = objfile->obfd;
	375	asection *isec = objsec->the_bfd_section;
	376	flagword flags = bfd_get_section_flags (ibfd, isec);
	377	int ret;
	378
	379	if ((flags & SEC_ALLOC) \|\| (flags & SEC_LOAD))
	380	{
	381	int size = bfd_section_size (ibfd, isec);
	382	int ret;
	383
	384	if ((ret = (*func) (objsec->addr,
	385	bfd_section_size (ibfd, isec),
386	1, /* All sections will be readable. */
387	(flags & SEC_READONLY) == 0, /* writable */
388	(flags & SEC_CODE) != 0, /* executable */
389	obfd)) != 0)
390	return ret;
391	}
392	}
393
394	/* Make a stack segment. */
395	if (derive_stack_segment (&temp_bottom, &temp_top))
396	(*func) (temp_bottom,
397	temp_top - temp_bottom,
398	1, /* Stack section will be readable */
399	1, /* Stack section will be writable */
400	0, /* Stack section will not be executable */
401	obfd);
402
403	/* Make a heap segment. */
404	if (derive_heap_segment (exec_bfd, &temp_bottom, &temp_top))
405	(*func) (temp_bottom,
406	temp_top - temp_bottom,
407	1, /* Heap section will be readable */
408	1, /* Heap section will be writable */
409	0, /* Heap section will not be executable */
410	obfd);
411	return 0;
412	}
413
414	static void
415	gcore_copy_callback (bfd obfd, asection osec, void *ignored)
416	{
417	bfd_size_type size = bfd_section_size (obfd, osec);
418	struct cleanup *old_chain = NULL;
419	void *memhunk;
420
421	if (size == 0)
422	return; /* Read-only sections are marked as zero-size.
423	We don't have to copy their contents. */
20fe79c8	424	if (strncmp ("load", bfd_section_name (obfd, osec), 4) != 0)
be4d1333 MS	425	return; /* Only interested in "load" sections. */
	426
	427	if ((memhunk = xmalloc (size)) == NULL)
	428	error ("Not enough memory to create corefile.");
	429	old_chain = make_cleanup (xfree, memhunk);
	430
	431	if (target_read_memory (bfd_section_vma (obfd, osec),
	432	memhunk, size) != 0)
	433	warning ("Memory read failed for corefile section, %ld bytes at 0x%s\n",
	434	(long) size, paddr (bfd_section_vma (obfd, osec)));
	435	if (!bfd_set_section_contents (obfd, osec, memhunk, 0, size))
	436	warning ("Failed to write corefile contents (%s).",
	437	bfd_errmsg (bfd_get_error ()));
	438
	439	do_cleanups (old_chain); /* frees the xmalloc buffer */
	440	}
	441
	442	static int
	443	gcore_memory_sections (bfd *obfd)
	444	{
	445	if (target_find_memory_regions (gcore_create_callback, obfd) != 0)
	446	return 0; /* FIXME error return/msg? */
	447
	448	/* Record phdrs for section-to-segment mapping. */
	449	bfd_map_over_sections (obfd, make_output_phdrs, NULL);
	450
	451	/* Copy memory region contents. */
	452	bfd_map_over_sections (obfd, gcore_copy_callback, NULL);
	453
	454	return 1; /* success */
	455	}
	456
	457	void
	458	_initialize_gcore (void)
	459	{
	460	add_com ("generate-core-file", class_files, gcore_command,
	461	"Save a core file with the current state of the debugged process.\n\
	462	Argument is optional filename. Default filename is 'core.<process_id>'.");
	463
	464	add_com_alias ("gcore", "generate-core-file", class_files, 1);
	465	exec_set_find_memory_regions (objfile_find_memory_regions);
	466	}