[binutils.git] / gdb / gcore.c

/* Generate a core file for the inferior process.

   Copyright 2001, 2002, 2003 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"
#include "infcall.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 = get_frame_base (fi);
  /* 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 = get_frame_base (fi);

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