[binutils.git] / gdb / arm-xdep.c

/* Acorn Risc Machine host machine support.
   Copyright (C) 1988, 1989, 1991 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 "frame.h"
#include "inferior.h"
#include "arm-opcode.h"

#include <sys/param.h>
#include <sys/dir.h>
#include <signal.h>
#include <sys/ioctl.h>
#include <sys/ptrace.h>
#include <machine/reg.h>

#define N_TXTADDR(hdr) 0x8000
#define N_DATADDR(hdr) (hdr.a_text + 0x8000)

#include "gdbcore.h"

#include <sys/user.h>		/* After a.out.h  */
#include <sys/file.h>
#include "gdb_stat.h"

#include <errno.h>

void
fetch_inferior_registers (regno)
     int regno;		/* Original value discarded */
{
  register unsigned int regaddr;
  char buf[MAX_REGISTER_RAW_SIZE];
  register int i;

  struct user u;
  unsigned int offset = (char *) &u.u_ar0 - (char *) &u;
  offset = ptrace (PT_READ_U, inferior_pid, (PTRACE_ARG3_TYPE) offset, 0)
      - KERNEL_U_ADDR;

  registers_fetched ();
  
  for (regno = 0; regno < 16; regno++)
    {
      regaddr = offset + regno * 4;
      *(int *)&buf[0] = ptrace (PT_READ_U, inferior_pid,
				(PTRACE_ARG3_TYPE) regaddr, 0);
      if (regno == PC_REGNUM)
	  *(int *)&buf[0] = GET_PC_PART(*(int *)&buf[0]);
      supply_register (regno, buf);
    }
  *(int *)&buf[0] = ptrace (PT_READ_U, inferior_pid,
			    (PTRACE_ARG3_TYPE) (offset + PC*4), 0);
  supply_register (PS_REGNUM, buf); /* set virtual register ps same as pc */

  /* read the floating point registers */
  offset = (char *) &u.u_fp_regs - (char *)&u;
  *(int *)buf = ptrace (PT_READ_U, inferior_pid, (PTRACE_ARG3_TYPE) offset, 0);
  supply_register (FPS_REGNUM, buf);
  for (regno = 16; regno < 24; regno++) {
      regaddr = offset + 4 + 12 * (regno - 16);
      for (i = 0; i < 12; i += sizeof(int))
	  *(int *) &buf[i] = ptrace (PT_READ_U, inferior_pid,
				     (PTRACE_ARG3_TYPE) (regaddr + i), 0);
      supply_register (regno, buf);
  }
}

/* Store our register values back into the inferior.
   If REGNO is -1, do this for all registers.
   Otherwise, REGNO specifies which register (so we can save time).  */

void
store_inferior_registers (regno)
     int regno;
{
  register unsigned int regaddr;
  char buf[80];

  struct user u;
  unsigned long value;
  unsigned int offset = (char *) &u.u_ar0 - (char *) &u;
  offset = ptrace (PT_READ_U, inferior_pid, (PTRACE_ARG3_TYPE) offset, 0)
      - KERNEL_U_ADDR;

  if (regno >= 0) {
      if (regno >= 16) return;
      regaddr = offset + 4 * regno;
      errno = 0;
      value = read_register(regno);
      if (regno == PC_REGNUM)
	  value = SET_PC_PART(read_register (PS_REGNUM), value);
      ptrace (PT_WRITE_U, inferior_pid, (PTRACE_ARG3_TYPE) regaddr, value);
      if (errno != 0)
	{
	  sprintf (buf, "writing register number %d", regno);
	  perror_with_name (buf);
	}
    }
  else for (regno = 0; regno < 15; regno++)
    {
      regaddr = offset + regno * 4;
      errno = 0;
      value = read_register(regno);
      if (regno == PC_REGNUM)
	  value = SET_PC_PART(read_register (PS_REGNUM), value);
      ptrace (6, inferior_pid, (PTRACE_ARG3_TYPE) regaddr, value);
      if (errno != 0)
	{
	  sprintf (buf, "writing all regs, number %d", regno);
	  perror_with_name (buf);
	}
    }
}
\f
/* Work with core dump and executable files, for GDB. 
   This code would be in corefile.c if it weren't machine-dependent. */

/* Structure to describe the chain of shared libraries used
   by the execfile.
   e.g. prog shares Xt which shares X11 which shares c. */

struct shared_library {
    struct exec_header header;
    char name[SHLIBLEN];
    CORE_ADDR text_start;	/* CORE_ADDR of 1st byte of text, this file */
    long data_offset;		/* offset of data section in file */
    int chan;			/* file descriptor for the file */
    struct shared_library *shares; /* library this one shares */
};
static struct shared_library *shlib = 0;

/* Hook for `exec_file_command' command to call.  */

extern void (*exec_file_display_hook) ();
   
static CORE_ADDR unshared_text_start;

/* extended header from exec file (for shared library info) */

static struct exec_header exec_header;
\f
void
core_file_command (filename, from_tty)
     char *filename;
     int from_tty;
{
  int val;
  extern char registers[];

  /* Discard all vestiges of any previous core file
     and mark data and stack spaces as empty.  */

  if (corefile)
    free (corefile);
  corefile = 0;

  if (corechan >= 0)
    close (corechan);
  corechan = -1;

  data_start = 0;
  data_end = 0;
  stack_start = STACK_END_ADDR;
  stack_end = STACK_END_ADDR;

  /* Now, if a new core file was specified, open it and digest it.  */

  if (filename)
    {
      filename = tilde_expand (filename);
      make_cleanup (free, filename);
      
      if (have_inferior_p ())
	error ("To look at a core file, you must kill the program with \"kill\".");
      corechan = open (filename, O_RDONLY, 0);
      if (corechan < 0)
	perror_with_name (filename);
      /* 4.2-style (and perhaps also sysV-style) core dump file.  */
      {
	struct user u;

	unsigned int reg_offset, fp_reg_offset;

	val = myread (corechan, &u, sizeof u);
	if (val < 0)
	  perror_with_name ("Not a core file: reading upage");
	if (val != sizeof u)
	  error ("Not a core file: could only read %d bytes", val);

	/* We are depending on exec_file_command having been called
	   previously to set exec_data_start.  Since the executable
	   and the core file share the same text segment, the address
	   of the data segment will be the same in both.  */
	data_start = exec_data_start;

	data_end = data_start + NBPG * u.u_dsize;
	stack_start = stack_end - NBPG * u.u_ssize;
	data_offset = NBPG * UPAGES;
	stack_offset = NBPG * (UPAGES + u.u_dsize);

	/* Some machines put an absolute address in here and some put
	   the offset in the upage of the regs.  */
	reg_offset = (int) u.u_ar0;
	if (reg_offset > NBPG * UPAGES)
	  reg_offset -= KERNEL_U_ADDR;
	fp_reg_offset = (char *) &u.u_fp_regs - (char *)&u;

	/* I don't know where to find this info.
	   So, for now, mark it as not available.  */
	N_SET_MAGIC (core_aouthdr, 0);

	/* Read the register values out of the core file and store
	   them where `read_register' will find them.  */

	{
	  register int regno;

	  for (regno = 0; regno < NUM_REGS; regno++)
	    {
	      char buf[MAX_REGISTER_RAW_SIZE];

	      if (regno < 16)
		  val = lseek (corechan, reg_offset + 4 * regno, 0);
	      else if (regno < 24)
		  val = lseek (corechan, fp_reg_offset + 4 + 12*(regno - 24), 0);
	      else if (regno == 24)
		  val = lseek (corechan, fp_reg_offset, 0);
	      else if (regno == 25)
		  val = lseek (corechan, reg_offset + 4 * PC, 0);
	      if (val < 0
		  || (val = myread (corechan, buf, sizeof buf)) < 0)
		{
		  char * buffer = (char *) alloca (strlen (reg_names[regno])
						   + 30);
		  strcpy (buffer, "Reading register ");
		  strcat (buffer, reg_names[regno]);
						   
		  perror_with_name (buffer);
		}

	      if (regno == PC_REGNUM)
		  *(int *)buf = GET_PC_PART(*(int *)buf);
	      supply_register (regno, buf);
	    }
	}
      }
      if (filename[0] == '/')
	corefile = savestring (filename, strlen (filename));
      else
	{
	  corefile = concat (current_directory, "/", filename, NULL);
	}

      flush_cached_frames ();
      select_frame (get_current_frame (), 0);
      validate_files ();
    }
  else if (from_tty)
    printf ("No core file now.\n");
}

#if 0
/* Work with core dump and executable files, for GDB. 
   This code would be in corefile.c if it weren't machine-dependent. */

/* Structure to describe the chain of shared libraries used
   by the execfile.
   e.g. prog shares Xt which shares X11 which shares c. */

struct shared_library {
    struct exec_header header;
    char name[SHLIBLEN];
    CORE_ADDR text_start;	/* CORE_ADDR of 1st byte of text, this file */
    long data_offset;		/* offset of data section in file */
    int chan;			/* file descriptor for the file */
    struct shared_library *shares; /* library this one shares */
};
static struct shared_library *shlib = 0;

/* Hook for `exec_file_command' command to call.  */

extern void (*exec_file_display_hook) ();
   
static CORE_ADDR unshared_text_start;

/* extended header from exec file (for shared library info) */

static struct exec_header exec_header;

void
exec_file_command (filename, from_tty)
     char *filename;
     int from_tty;
{
  int val;

  /* Eliminate all traces of old exec file.
     Mark text segment as empty.  */

  if (execfile)
    free (execfile);
  execfile = 0;
  data_start = 0;
  data_end -= exec_data_start;
  text_start = 0;
  unshared_text_start = 0;
  text_end = 0;
  exec_data_start = 0;
  exec_data_end = 0;
  if (execchan >= 0)
    close (execchan);
  execchan = -1;
  if (shlib) {
      close_shared_library(shlib);
      shlib = 0;
  }

  /* Now open and digest the file the user requested, if any.  */

  if (filename)
    {
      filename = tilde_expand (filename);
      make_cleanup (free, filename);

      execchan = openp (getenv ("PATH"), 1, filename, O_RDONLY, 0,
			&execfile);
      if (execchan < 0)
	perror_with_name (filename);

      {
	struct stat st_exec;

#ifdef HEADER_SEEK_FD
	HEADER_SEEK_FD (execchan);
#endif
	
	val = myread (execchan, &exec_header, sizeof exec_header);
	exec_aouthdr = exec_header.a_exec;

	if (val < 0)
	  perror_with_name (filename);

	text_start = 0x8000;

	/* Look for shared library if needed */
	if (exec_header.a_exec.a_magic & MF_USES_SL)
	    shlib = open_shared_library(exec_header.a_shlibname, text_start);

	text_offset = N_TXTOFF (exec_aouthdr);
	exec_data_offset = N_TXTOFF (exec_aouthdr) + exec_aouthdr.a_text;

	if (shlib) {
	    unshared_text_start = shared_text_end(shlib) & ~0x7fff;
	    stack_start = shlib->header.a_exec.a_sldatabase;
	    stack_end = STACK_END_ADDR;
	} else
	    unshared_text_start = 0x8000;
	text_end = unshared_text_start + exec_aouthdr.a_text;

	exec_data_start = unshared_text_start + exec_aouthdr.a_text;
        exec_data_end = exec_data_start + exec_aouthdr.a_data;

	data_start = exec_data_start;
	data_end += exec_data_start;

	fstat (execchan, &st_exec);
	exec_mtime = st_exec.st_mtime;
      }

      validate_files ();
    }
  else if (from_tty)
    printf ("No exec file now.\n");

  /* Tell display code (if any) about the changed file name.  */
  if (exec_file_display_hook)
    (*exec_file_display_hook) (filename);
}
#endif

#if 0
/* Read from the program's memory (except for inferior processes).
   This function is misnamed, since it only reads, never writes; and
   since it will use the core file and/or executable file as necessary.

   It should be extended to write as well as read, FIXME, for patching files.

   Return 0 if address could be read, EIO if addresss out of bounds.  */

int
xfer_core_file (memaddr, myaddr, len)
     CORE_ADDR memaddr;
     char *myaddr;
     int len;
{
  register int i;
  register int val;
  int xferchan;
  char **xferfile;
  int fileptr;
  int returnval = 0;

  while (len > 0)
    {
      xferfile = 0;
      xferchan = 0;

      /* Determine which file the next bunch of addresses reside in,
	 and where in the file.  Set the file's read/write pointer
	 to point at the proper place for the desired address
	 and set xferfile and xferchan for the correct file.

	 If desired address is nonexistent, leave them zero.

	 i is set to the number of bytes that can be handled
	 along with the next address.

	 We put the most likely tests first for efficiency.  */

      /* Note that if there is no core file
	 data_start and data_end are equal.  */
      if (memaddr >= data_start && memaddr < data_end)
	{
	  i = min (len, data_end - memaddr);
	  fileptr = memaddr - data_start + data_offset;
	  xferfile = &corefile;
	  xferchan = corechan;
	}
      /* Note that if there is no core file
	 stack_start and stack_end define the shared library data.  */
      else if (memaddr >= stack_start && memaddr < stack_end)
	{
	    if (corechan < 0) {
		struct shared_library *lib;
		for (lib = shlib; lib; lib = lib->shares)
		    if (memaddr >= lib->header.a_exec.a_sldatabase &&
			memaddr < lib->header.a_exec.a_sldatabase +
			  lib->header.a_exec.a_data)
			break;
		if (lib) {
		    i = min (len, lib->header.a_exec.a_sldatabase +
			     lib->header.a_exec.a_data - memaddr);
		    fileptr = lib->data_offset + memaddr -
			lib->header.a_exec.a_sldatabase;
		    xferfile = execfile;
		    xferchan = lib->chan;
		}
	    } else {
		i = min (len, stack_end - memaddr);
		fileptr = memaddr - stack_start + stack_offset;
		xferfile = &corefile;
		xferchan = corechan;
	    }
	}
      else if (corechan < 0
	       && memaddr >= exec_data_start && memaddr < exec_data_end)
	{
	  i = min (len, exec_data_end - memaddr);
	  fileptr = memaddr - exec_data_start + exec_data_offset;
	  xferfile = &execfile;
	  xferchan = execchan;
	}
      else if (memaddr >= text_start && memaddr < text_end)
	{
	    struct shared_library *lib;
	    for (lib = shlib; lib; lib = lib->shares)
		if (memaddr >= lib->text_start &&
		    memaddr < lib->text_start + lib->header.a_exec.a_text)
		    break;
	    if (lib) {
		i = min (len, lib->header.a_exec.a_text +
			 lib->text_start - memaddr);
		fileptr = memaddr - lib->text_start + text_offset;
		xferfile = &execfile;
		xferchan = lib->chan;
	    } else {
		i = min (len, text_end - memaddr);
		fileptr = memaddr - unshared_text_start + text_offset;
		xferfile = &execfile;
		xferchan = execchan;
	    }
	}
      else if (memaddr < text_start)
	{
	  i = min (len, text_start - memaddr);
	}
      else if (memaddr >= text_end
	       && memaddr < (corechan >= 0? data_start : exec_data_start))
	{
	  i = min (len, data_start - memaddr);
	}
      else if (corechan >= 0
	       && memaddr >= data_end && memaddr < stack_start)
	{
	  i = min (len, stack_start - memaddr);
	}
      else if (corechan < 0 && memaddr >= exec_data_end)
	{
	  i = min (len, - memaddr);
	}
      else if (memaddr >= stack_end && stack_end != 0)
	{
	  i = min (len, - memaddr);
	}
      else
	{
	  /* Address did not classify into one of the known ranges.
	     This shouldn't happen; we catch the endpoints.  */
	  fatal ("Internal: Bad case logic in xfer_core_file.");
	}

      /* Now we know which file to use.
	 Set up its pointer and transfer the data.  */
      if (xferfile)
	{
	  if (*xferfile == 0)
	    if (xferfile == &execfile)
	      error ("No program file to examine.");
	    else
	      error ("No core dump file or running program to examine.");
	  val = lseek (xferchan, fileptr, 0);
	  if (val < 0)
	    perror_with_name (*xferfile);
	  val = myread (xferchan, myaddr, i);
	  if (val < 0)
	    perror_with_name (*xferfile);
	}
      /* If this address is for nonexistent memory,
	 read zeros if reading, or do nothing if writing.
	 Actually, we never right.  */
      else
	{
	  memset (myaddr, '\0', i);
	  returnval = EIO;
	}

      memaddr += i;
      myaddr += i;
      len -= i;
    }
  return returnval;
}
#endif
Commit	Line	Data
dd3b648e RP	1	/* Acorn Risc Machine host machine support.
	2	Copyright (C) 1988, 1989, 1991 Free Software Foundation, Inc.
	3
	4	This file is part of GDB.
	5
99a7de40	6	This program is free software; you can redistribute it and/or modify
dd3b648e	7	it under the terms of the GNU General Public License as published by
99a7de40 JG	8	the Free Software Foundation; either version 2 of the License, or
99a7de40 JG	9	(at your option) any later version.
dd3b648e	10
99a7de40	11	This program is distributed in the hope that it will be useful,
dd3b648e RP	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
99a7de40	17	along with this program; if not, write to the Free Software
6c9638b4	18	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
dd3b648e RP	19
dd3b648e RP	20	#include "defs.h"
dd3b648e RP	21	#include "frame.h"
	22	#include "inferior.h"
	23	#include "arm-opcode.h"
	24
dd3b648e RP	25	#include <sys/param.h>
	26	#include <sys/dir.h>
	27	#include <signal.h>
	28	#include <sys/ioctl.h>
	29	#include <sys/ptrace.h>
	30	#include <machine/reg.h>
	31
	32	#define N_TXTADDR(hdr) 0x8000
	33	#define N_DATADDR(hdr) (hdr.a_text + 0x8000)
	34
	35	#include "gdbcore.h"
	36
	37	#include <sys/user.h> /* After a.out.h */
	38	#include <sys/file.h>
2b576293	39	#include "gdb_stat.h"
dd3b648e RP	40
	41	#include <errno.h>
	42
	43	void
	44	fetch_inferior_registers (regno)
1ab3bf1b	45	int regno; /* Original value discarded */
dd3b648e	46	{
dd3b648e RP	47	register unsigned int regaddr;
	48	char buf[MAX_REGISTER_RAW_SIZE];
	49	register int i;
	50
	51	struct user u;
	52	unsigned int offset = (char ) &u.u_ar0 - (char ) &u;
e676a15f FF	53	offset = ptrace (PT_READ_U, inferior_pid, (PTRACE_ARG3_TYPE) offset, 0)
e676a15f FF	54	- KERNEL_U_ADDR;
dd3b648e RP	55
	56	registers_fetched ();
	57
	58	for (regno = 0; regno < 16; regno++)
	59	{
	60	regaddr = offset + regno * 4;
e676a15f FF	61	(int )&buf[0] = ptrace (PT_READ_U, inferior_pid,
e676a15f FF	62	(PTRACE_ARG3_TYPE) regaddr, 0);
dd3b648e RP	63	if (regno == PC_REGNUM)
	64	(int )&buf[0] = GET_PC_PART((int )&buf[0]);
	65	supply_register (regno, buf);
	66	}
e676a15f FF	67	(int )&buf[0] = ptrace (PT_READ_U, inferior_pid,
e676a15f FF	68	(PTRACE_ARG3_TYPE) (offset + PC*4), 0);
dd3b648e RP	69	supply_register (PS_REGNUM, buf); /* set virtual register ps same as pc */
	70
	71	/* read the floating point registers */
	72	offset = (char ) &u.u_fp_regs - (char )&u;
e676a15f	73	(int )buf = ptrace (PT_READ_U, inferior_pid, (PTRACE_ARG3_TYPE) offset, 0);
dd3b648e RP	74	supply_register (FPS_REGNUM, buf);
	75	for (regno = 16; regno < 24; regno++) {
	76	regaddr = offset + 4 + 12 * (regno - 16);
	77	for (i = 0; i < 12; i += sizeof(int))
e676a15f FF	78	(int ) &buf[i] = ptrace (PT_READ_U, inferior_pid,
e676a15f FF	79	(PTRACE_ARG3_TYPE) (regaddr + i), 0);
dd3b648e RP	80	supply_register (regno, buf);
	81	}
	82	}
	83
	84	/* Store our register values back into the inferior.
	85	If REGNO is -1, do this for all registers.
	86	Otherwise, REGNO specifies which register (so we can save time). */
	87
1ab3bf1b	88	void
dd3b648e RP	89	store_inferior_registers (regno)
	90	int regno;
	91	{
	92	register unsigned int regaddr;
	93	char buf[80];
	94
	95	struct user u;
	96	unsigned long value;
	97	unsigned int offset = (char ) &u.u_ar0 - (char ) &u;
e676a15f FF	98	offset = ptrace (PT_READ_U, inferior_pid, (PTRACE_ARG3_TYPE) offset, 0)
e676a15f FF	99	- KERNEL_U_ADDR;
dd3b648e RP	100
	101	if (regno >= 0) {
	102	if (regno >= 16) return;
	103	regaddr = offset + 4 * regno;
	104	errno = 0;
	105	value = read_register(regno);
	106	if (regno == PC_REGNUM)
	107	value = SET_PC_PART(read_register (PS_REGNUM), value);
e676a15f	108	ptrace (PT_WRITE_U, inferior_pid, (PTRACE_ARG3_TYPE) regaddr, value);
dd3b648e RP	109	if (errno != 0)
	110	{
	111	sprintf (buf, "writing register number %d", regno);
	112	perror_with_name (buf);
	113	}
	114	}
	115	else for (regno = 0; regno < 15; regno++)
	116	{
	117	regaddr = offset + regno * 4;
	118	errno = 0;
	119	value = read_register(regno);
	120	if (regno == PC_REGNUM)
	121	value = SET_PC_PART(read_register (PS_REGNUM), value);
e676a15f	122	ptrace (6, inferior_pid, (PTRACE_ARG3_TYPE) regaddr, value);
dd3b648e RP	123	if (errno != 0)
	124	{
	125	sprintf (buf, "writing all regs, number %d", regno);
	126	perror_with_name (buf);
	127	}
	128	}
	129	}
	130	\f
	131	/* Work with core dump and executable files, for GDB.
1738bcd3	132	This code would be in corefile.c if it weren't machine-dependent. */
dd3b648e RP	133
	134	/* Structure to describe the chain of shared libraries used
	135	by the execfile.
	136	e.g. prog shares Xt which shares X11 which shares c. */
	137
	138	struct shared_library {
	139	struct exec_header header;
	140	char name[SHLIBLEN];
	141	CORE_ADDR text_start; /* CORE_ADDR of 1st byte of text, this file */
	142	long data_offset; /* offset of data section in file */
	143	int chan; /* file descriptor for the file */
	144	struct shared_library shares; / library this one shares */
	145	};
	146	static struct shared_library *shlib = 0;
	147
	148	/* Hook for `exec_file_command' command to call. */
	149
	150	extern void (*exec_file_display_hook) ();
	151
	152	static CORE_ADDR unshared_text_start;
	153
	154	/* extended header from exec file (for shared library info) */
	155
	156	static struct exec_header exec_header;
	157	\f
	158	void
	159	core_file_command (filename, from_tty)
	160	char *filename;
	161	int from_tty;
	162	{
	163	int val;
	164	extern char registers[];
	165
	166	/* Discard all vestiges of any previous core file
	167	and mark data and stack spaces as empty. */
	168
	169	if (corefile)
	170	free (corefile);
	171	corefile = 0;
	172
	173	if (corechan >= 0)
	174	close (corechan);
	175	corechan = -1;
	176
	177	data_start = 0;
	178	data_end = 0;
	179	stack_start = STACK_END_ADDR;
	180	stack_end = STACK_END_ADDR;
	181
	182	/* Now, if a new core file was specified, open it and digest it. */
	183
	184	if (filename)
	185	{
	186	filename = tilde_expand (filename);
	187	make_cleanup (free, filename);
	188
	189	if (have_inferior_p ())
6fe90fc8	190	error ("To look at a core file, you must kill the program with \"kill\".");
dd3b648e RP	191	corechan = open (filename, O_RDONLY, 0);
	192	if (corechan < 0)
	193	perror_with_name (filename);
	194	/* 4.2-style (and perhaps also sysV-style) core dump file. */
	195	{
	196	struct user u;
	197
	198	unsigned int reg_offset, fp_reg_offset;
	199
	200	val = myread (corechan, &u, sizeof u);
	201	if (val < 0)
	202	perror_with_name ("Not a core file: reading upage");
	203	if (val != sizeof u)
	204	error ("Not a core file: could only read %d bytes", val);
	205
	206	/* We are depending on exec_file_command having been called
	207	previously to set exec_data_start. Since the executable
	208	and the core file share the same text segment, the address
	209	of the data segment will be the same in both. */
	210	data_start = exec_data_start;
	211
	212	data_end = data_start + NBPG * u.u_dsize;
	213	stack_start = stack_end - NBPG * u.u_ssize;
	214	data_offset = NBPG * UPAGES;
	215	stack_offset = NBPG * (UPAGES + u.u_dsize);
	216
	217	/* Some machines put an absolute address in here and some put
	218	the offset in the upage of the regs. */
	219	reg_offset = (int) u.u_ar0;
	220	if (reg_offset > NBPG * UPAGES)
	221	reg_offset -= KERNEL_U_ADDR;
	222	fp_reg_offset = (char ) &u.u_fp_regs - (char )&u;
	223
	224	/* I don't know where to find this info.
	225	So, for now, mark it as not available. */
	226	N_SET_MAGIC (core_aouthdr, 0);
	227
	228	/* Read the register values out of the core file and store
	229	them where `read_register' will find them. */
	230
	231	{
	232	register int regno;
	233
	234	for (regno = 0; regno < NUM_REGS; regno++)
	235	{
	236	char buf[MAX_REGISTER_RAW_SIZE];
	237
	238	if (regno < 16)
	239	val = lseek (corechan, reg_offset + 4 * regno, 0);
	240	else if (regno < 24)
	241	val = lseek (corechan, fp_reg_offset + 4 + 12*(regno - 24), 0);
	242	else if (regno == 24)
	243	val = lseek (corechan, fp_reg_offset, 0);
	244	else if (regno == 25)
	245	val = lseek (corechan, reg_offset + 4 * PC, 0);
	246	if (val < 0
	247	\|\| (val = myread (corechan, buf, sizeof buf)) < 0)
	248	{
	249	char * buffer = (char *) alloca (strlen (reg_names[regno])
	250	+ 30);
	251	strcpy (buffer, "Reading register ");
	252	strcat (buffer, reg_names[regno]);
	253
	254	perror_with_name (buffer);
255	}
256
257	if (regno == PC_REGNUM)
258	(int )buf = GET_PC_PART((int )buf);
259	supply_register (regno, buf);
260	}
261	}
262	}
263	if (filename[0] == '/')
264	corefile = savestring (filename, strlen (filename));
265	else
266	{
58ae87f6	267	corefile = concat (current_directory, "/", filename, NULL);
dd3b648e RP	268	}
dd3b648e RP	269
16726dd1	270	flush_cached_frames ();
dd3b648e RP	271	select_frame (get_current_frame (), 0);
	272	validate_files ();
	273	}
	274	else if (from_tty)
	275	printf ("No core file now.\n");
	276	}
72c9954b SS	277
	278	#if 0
	279	/* Work with core dump and executable files, for GDB.
	280	This code would be in corefile.c if it weren't machine-dependent. */
	281
	282	/* Structure to describe the chain of shared libraries used
	283	by the execfile.
	284	e.g. prog shares Xt which shares X11 which shares c. */
	285
	286	struct shared_library {
	287	struct exec_header header;
	288	char name[SHLIBLEN];
	289	CORE_ADDR text_start; /* CORE_ADDR of 1st byte of text, this file */
	290	long data_offset; /* offset of data section in file */
	291	int chan; /* file descriptor for the file */
	292	struct shared_library shares; / library this one shares */
	293	};
	294	static struct shared_library *shlib = 0;
	295
	296	/* Hook for `exec_file_command' command to call. */
	297
	298	extern void (*exec_file_display_hook) ();
	299
	300	static CORE_ADDR unshared_text_start;
	301
	302	/* extended header from exec file (for shared library info) */
	303
	304	static struct exec_header exec_header;
	305
	306	void
	307	exec_file_command (filename, from_tty)
	308	char *filename;
	309	int from_tty;
	310	{
	311	int val;
	312
	313	/* Eliminate all traces of old exec file.
	314	Mark text segment as empty. */
	315
	316	if (execfile)
	317	free (execfile);
	318	execfile = 0;
	319	data_start = 0;
	320	data_end -= exec_data_start;
	321	text_start = 0;
	322	unshared_text_start = 0;
	323	text_end = 0;
	324	exec_data_start = 0;
	325	exec_data_end = 0;
	326	if (execchan >= 0)
	327	close (execchan);
	328	execchan = -1;
	329	if (shlib) {
	330	close_shared_library(shlib);
	331	shlib = 0;
	332	}
	333
	334	/* Now open and digest the file the user requested, if any. */
	335
	336	if (filename)
	337	{
	338	filename = tilde_expand (filename);
	339	make_cleanup (free, filename);
	340
341	execchan = openp (getenv ("PATH"), 1, filename, O_RDONLY, 0,
342	&execfile);
343	if (execchan < 0)
344	perror_with_name (filename);
345
346	{
347	struct stat st_exec;
348
349	#ifdef HEADER_SEEK_FD
350	HEADER_SEEK_FD (execchan);
351	#endif
352
353	val = myread (execchan, &exec_header, sizeof exec_header);
354	exec_aouthdr = exec_header.a_exec;
355
356	if (val < 0)
357	perror_with_name (filename);
358
359	text_start = 0x8000;
360
361	/* Look for shared library if needed */
362	if (exec_header.a_exec.a_magic & MF_USES_SL)
363	shlib = open_shared_library(exec_header.a_shlibname, text_start);
364
365	text_offset = N_TXTOFF (exec_aouthdr);
366	exec_data_offset = N_TXTOFF (exec_aouthdr) + exec_aouthdr.a_text;
367
368	if (shlib) {
369	unshared_text_start = shared_text_end(shlib) & ~0x7fff;
370	stack_start = shlib->header.a_exec.a_sldatabase;
371	stack_end = STACK_END_ADDR;
372	} else
373	unshared_text_start = 0x8000;
374	text_end = unshared_text_start + exec_aouthdr.a_text;
375
376	exec_data_start = unshared_text_start + exec_aouthdr.a_text;
377	exec_data_end = exec_data_start + exec_aouthdr.a_data;
378
379	data_start = exec_data_start;
380	data_end += exec_data_start;
381
382	fstat (execchan, &st_exec);
383	exec_mtime = st_exec.st_mtime;
384	}
385
386	validate_files ();
387	}
388	else if (from_tty)
389	printf ("No exec file now.\n");
390
391	/* Tell display code (if any) about the changed file name. */
392	if (exec_file_display_hook)
393	(*exec_file_display_hook) (filename);
394	}
395	#endif
396
397	#if 0
398	/* Read from the program's memory (except for inferior processes).
399	This function is misnamed, since it only reads, never writes; and
400	since it will use the core file and/or executable file as necessary.
401
402	It should be extended to write as well as read, FIXME, for patching files.
403
404	Return 0 if address could be read, EIO if addresss out of bounds. */
405
406	int
407	xfer_core_file (memaddr, myaddr, len)
408	CORE_ADDR memaddr;
409	char *myaddr;
410	int len;
411	{
412	register int i;
413	register int val;
414	int xferchan;
415	char **xferfile;
416	int fileptr;
417	int returnval = 0;
418
419	while (len > 0)
420	{
421	xferfile = 0;
422	xferchan = 0;
423
424	/* Determine which file the next bunch of addresses reside in,
425	and where in the file. Set the file's read/write pointer
426	to point at the proper place for the desired address
427	and set xferfile and xferchan for the correct file.
428
429	If desired address is nonexistent, leave them zero.
430
431	i is set to the number of bytes that can be handled
432	along with the next address.
433
434	We put the most likely tests first for efficiency. */
435
436	/* Note that if there is no core file
437	data_start and data_end are equal. */
438	if (memaddr >= data_start && memaddr < data_end)
439	{
440	i = min (len, data_end - memaddr);
441	fileptr = memaddr - data_start + data_offset;
442	xferfile = &corefile;
443	xferchan = corechan;
444	}
445	/* Note that if there is no core file
446	stack_start and stack_end define the shared library data. */
447	else if (memaddr >= stack_start && memaddr < stack_end)
448	{
449	if (corechan < 0) {
450	struct shared_library *lib;
451	for (lib = shlib; lib; lib = lib->shares)
452	if (memaddr >= lib->header.a_exec.a_sldatabase &&
453	memaddr < lib->header.a_exec.a_sldatabase +
454	lib->header.a_exec.a_data)
455	break;
456	if (lib) {
457	i = min (len, lib->header.a_exec.a_sldatabase +
458	lib->header.a_exec.a_data - memaddr);
459	fileptr = lib->data_offset + memaddr -
460	lib->header.a_exec.a_sldatabase;
461	xferfile = execfile;
462	xferchan = lib->chan;
463	}
464	} else {
465	i = min (len, stack_end - memaddr);
466	fileptr = memaddr - stack_start + stack_offset;
467	xferfile = &corefile;
468	xferchan = corechan;
469	}
470	}
471	else if (corechan < 0
472	&& memaddr >= exec_data_start && memaddr < exec_data_end)
473	{
474	i = min (len, exec_data_end - memaddr);
475	fileptr = memaddr - exec_data_start + exec_data_offset;
476	xferfile = &execfile;
477	xferchan = execchan;
478	}
479	else if (memaddr >= text_start && memaddr < text_end)
480	{
481	struct shared_library *lib;
482	for (lib = shlib; lib; lib = lib->shares)
483	if (memaddr >= lib->text_start &&
484	memaddr < lib->text_start + lib->header.a_exec.a_text)
485	break;
486	if (lib) {
487	i = min (len, lib->header.a_exec.a_text +
488	lib->text_start - memaddr);
489	fileptr = memaddr - lib->text_start + text_offset;
490	xferfile = &execfile;
491	xferchan = lib->chan;
492	} else {
493	i = min (len, text_end - memaddr);
494	fileptr = memaddr - unshared_text_start + text_offset;
495	xferfile = &execfile;
496	xferchan = execchan;
497	}
498	}
499	else if (memaddr < text_start)
500	{
501	i = min (len, text_start - memaddr);
502	}
503	else if (memaddr >= text_end
504	&& memaddr < (corechan >= 0? data_start : exec_data_start))
505	{
506	i = min (len, data_start - memaddr);
507	}
508	else if (corechan >= 0
509	&& memaddr >= data_end && memaddr < stack_start)
510	{
511	i = min (len, stack_start - memaddr);
512	}
513	else if (corechan < 0 && memaddr >= exec_data_end)
514	{
515	i = min (len, - memaddr);
516	}
517	else if (memaddr >= stack_end && stack_end != 0)
518	{
519	i = min (len, - memaddr);
520	}
521	else
522	{
523	/* Address did not classify into one of the known ranges.
524	This shouldn't happen; we catch the endpoints. */
525	fatal ("Internal: Bad case logic in xfer_core_file.");
526	}
527
528	/* Now we know which file to use.
529	Set up its pointer and transfer the data. */
530	if (xferfile)
531	{
532	if (*xferfile == 0)
533	if (xferfile == &execfile)
534	error ("No program file to examine.");
535	else
536	error ("No core dump file or running program to examine.");
537	val = lseek (xferchan, fileptr, 0);
538	if (val < 0)
539	perror_with_name (*xferfile);
540	val = myread (xferchan, myaddr, i);
541	if (val < 0)
542	perror_with_name (*xferfile);
543	}
544	/* If this address is for nonexistent memory,
545	read zeros if reading, or do nothing if writing.
546	Actually, we never right. */
547	else
548	{
549	memset (myaddr, '\0', i);
550	returnval = EIO;
551	}
552
553	memaddr += i;
554	myaddr += i;
555	len -= i;
556	}
557	return returnval;
558	}
559	#endif